fidl_fuchsia_media_sessions2/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ActiveSessionWatchActiveSessionResponse {
    pub session: Option<fidl::endpoints::ClientEnd<SessionControlMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DiscoveryConnectToSessionRequest {
    pub session_id: u64,
    pub session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct DiscoveryWatchSessionsRequest {
    pub watch_options: WatchOptions,
    pub session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ObserverDiscoveryConnectToSessionRequest {
    pub session_id: u64,
    pub session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct ObserverDiscoveryWatchSessionsRequest {
    pub watch_options: WatchOptions,
    pub sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PlayerControlBindVolumeControlRequest {
    pub volume_control_request:
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PublisherPublishRequest {
    pub player: fidl::endpoints::ClientEnd<PlayerMarker>,
    pub registration: PlayerRegistration,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionControlBindVolumeControlRequest {
    pub volume_control_request:
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for ActiveSessionMarker {
    type Proxy = ActiveSessionProxy;
    type RequestStream = ActiveSessionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ActiveSessionSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.sessions2.ActiveSession";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ActiveSessionMarker {}

pub trait ActiveSessionProxyInterface: Send + Sync {
    type WatchActiveSessionResponseFut: std::future::Future<
            Output = Result<Option<fidl::endpoints::ClientEnd<SessionControlMarker>>, fidl::Error>,
        > + Send;
    fn r#watch_active_session(&self) -> Self::WatchActiveSessionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ActiveSessionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ActiveSessionSynchronousProxy {
    type Proxy = ActiveSessionProxy;
    type Protocol = ActiveSessionMarker;

    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 ActiveSessionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ActiveSessionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Watches the active session. The first request will be answered immediately
    /// with the current active session. Always leave a request hanging to receive
    /// a reply when the active session changes.
    pub fn r#watch_active_session(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<fidl::endpoints::ClientEnd<SessionControlMarker>>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, ActiveSessionWatchActiveSessionResponse>(
                (),
                0xc072168d525fff8,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.session)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ActiveSessionProxy {
    type Protocol = ActiveSessionMarker;

    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 ActiveSessionProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/ActiveSession.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ActiveSessionMarker 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) -> ActiveSessionEventStream {
        ActiveSessionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Watches the active session. The first request will be answered immediately
    /// with the current active session. Always leave a request hanging to receive
    /// a reply when the active session changes.
    pub fn r#watch_active_session(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<SessionControlMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ActiveSessionProxyInterface::r#watch_active_session(self)
    }
}

impl ActiveSessionProxyInterface for ActiveSessionProxy {
    type WatchActiveSessionResponseFut = fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<SessionControlMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_active_session(&self) -> Self::WatchActiveSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<fidl::endpoints::ClientEnd<SessionControlMarker>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ActiveSessionWatchActiveSessionResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xc072168d525fff8,
            >(_buf?)?;
            Ok(_response.session)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            Option<fidl::endpoints::ClientEnd<SessionControlMarker>>,
        >(
            (),
            0xc072168d525fff8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/ActiveSession.
pub struct ActiveSessionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ActiveSessionRequestStream {
    type Protocol = ActiveSessionMarker;
    type ControlHandle = ActiveSessionControlHandle;

    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 {
        ActiveSessionControlHandle { 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 ActiveSessionRequestStream {
    type Item = Result<ActiveSessionRequest, 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 ActiveSessionRequestStream 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 {
                    0xc072168d525fff8 => {
                        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 =
                            ActiveSessionControlHandle { inner: this.inner.clone() };
                        Ok(ActiveSessionRequest::WatchActiveSession {
                            responder: ActiveSessionWatchActiveSessionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ActiveSessionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol for watching the current active media session on the device.
///
/// The currently active media session is the most recent existing media session
/// to announce a "Playing" state on the local device, even if it is now paused.
#[derive(Debug)]
pub enum ActiveSessionRequest {
    /// Watches the active session. The first request will be answered immediately
    /// with the current active session. Always leave a request hanging to receive
    /// a reply when the active session changes.
    WatchActiveSession { responder: ActiveSessionWatchActiveSessionResponder },
}

impl ActiveSessionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_active_session(self) -> Option<(ActiveSessionWatchActiveSessionResponder)> {
        if let ActiveSessionRequest::WatchActiveSession { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut session: Option<fidl::endpoints::ClientEnd<SessionControlMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ActiveSessionWatchActiveSessionResponse>(
            (session,),
            self.tx_id,
            0xc072168d525fff8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DiscoveryMarker {
    type Proxy = DiscoveryProxy;
    type RequestStream = DiscoveryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DiscoverySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.sessions2.Discovery";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DiscoveryMarker {}

pub trait DiscoveryProxyInterface: Send + Sync {
    fn r#watch_sessions(
        &self,
        watch_options: &WatchOptions,
        session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#connect_to_session(
        &self,
        session_id: u64,
        session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DiscoverySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DiscoverySynchronousProxy {
    type Proxy = DiscoveryProxy;
    type Protocol = DiscoveryMarker;

    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 DiscoverySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DiscoveryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Connects a session watcher configured with the given options.
    pub fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DiscoveryWatchSessionsRequest>(
            (watch_options, session_watcher),
            0x4231b30d98dcd2fe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connects to a `SessionControl` for `session_id` if present. Drops the
    /// given channel otherwise.
    pub fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DiscoveryConnectToSessionRequest>(
            (session_id, session_control_request),
            0x37da54e09f63ca3d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DiscoveryProxy {
    type Protocol = DiscoveryMarker;

    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 DiscoveryProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/Discovery.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DiscoveryMarker 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) -> DiscoveryEventStream {
        DiscoveryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects a session watcher configured with the given options.
    pub fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        DiscoveryProxyInterface::r#watch_sessions(self, watch_options, session_watcher)
    }

    /// Connects to a `SessionControl` for `session_id` if present. Drops the
    /// given channel otherwise.
    pub fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
    ) -> Result<(), fidl::Error> {
        DiscoveryProxyInterface::r#connect_to_session(self, session_id, session_control_request)
    }
}

impl DiscoveryProxyInterface for DiscoveryProxy {
    fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DiscoveryWatchSessionsRequest>(
            (watch_options, session_watcher),
            0x4231b30d98dcd2fe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DiscoveryConnectToSessionRequest>(
            (session_id, session_control_request),
            0x37da54e09f63ca3d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/Discovery.
pub struct DiscoveryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DiscoveryRequestStream {
    type Protocol = DiscoveryMarker;
    type ControlHandle = DiscoveryControlHandle;

    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 {
        DiscoveryControlHandle { 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 DiscoveryRequestStream {
    type Item = Result<DiscoveryRequest, 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 DiscoveryRequestStream 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 {
                    0x4231b30d98dcd2fe => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DiscoveryWatchSessionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DiscoveryWatchSessionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DiscoveryControlHandle { inner: this.inner.clone() };
                        Ok(DiscoveryRequest::WatchSessions {
                            watch_options: req.watch_options,
                            session_watcher: req.session_watcher,

                            control_handle,
                        })
                    }
                    0x37da54e09f63ca3d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DiscoveryConnectToSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DiscoveryConnectToSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DiscoveryControlHandle { inner: this.inner.clone() };
                        Ok(DiscoveryRequest::ConnectToSession {
                            session_id: req.session_id,
                            session_control_request: req.session_control_request,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DiscoveryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `Discovery` observes the collection of published media sessions
/// and connects clients to them.
#[derive(Debug)]
pub enum DiscoveryRequest {
    /// Connects a session watcher configured with the given options.
    WatchSessions {
        watch_options: WatchOptions,
        session_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
        control_handle: DiscoveryControlHandle,
    },
    /// Connects to a `SessionControl` for `session_id` if present. Drops the
    /// given channel otherwise.
    ConnectToSession {
        session_id: u64,
        session_control_request: fidl::endpoints::ServerEnd<SessionControlMarker>,
        control_handle: DiscoveryControlHandle,
    },
}

impl DiscoveryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_sessions(
        self,
    ) -> Option<(
        WatchOptions,
        fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
        DiscoveryControlHandle,
    )> {
        if let DiscoveryRequest::WatchSessions { watch_options, session_watcher, control_handle } =
            self
        {
            Some((watch_options, session_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_session(
        self,
    ) -> Option<(u64, fidl::endpoints::ServerEnd<SessionControlMarker>, DiscoveryControlHandle)>
    {
        if let DiscoveryRequest::ConnectToSession {
            session_id,
            session_control_request,
            control_handle,
        } = self
        {
            Some((session_id, session_control_request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DiscoveryRequest::WatchSessions { .. } => "watch_sessions",
            DiscoveryRequest::ConnectToSession { .. } => "connect_to_session",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for ObserverDiscoveryMarker {
    type Proxy = ObserverDiscoveryProxy;
    type RequestStream = ObserverDiscoveryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ObserverDiscoverySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.sessions2.ObserverDiscovery";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ObserverDiscoveryMarker {}

pub trait ObserverDiscoveryProxyInterface: Send + Sync {
    fn r#watch_sessions(
        &self,
        watch_options: &WatchOptions,
        sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#connect_to_session(
        &self,
        session_id: u64,
        session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ObserverDiscoverySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ObserverDiscoverySynchronousProxy {
    type Proxy = ObserverDiscoveryProxy;
    type Protocol = ObserverDiscoveryMarker;

    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 ObserverDiscoverySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ObserverDiscoveryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Connects a session watcher configured with the given options.
    pub fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ObserverDiscoveryWatchSessionsRequest>(
            (watch_options, sessions_watcher),
            0x3d95eaa20624a1fe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connects to a `SessionObserver` for `session_id` if present. Drops the
    /// given channel otherwise.
    pub fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ObserverDiscoveryConnectToSessionRequest>(
            (session_id, session_request),
            0x2c9b99aacfaac87a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ObserverDiscoveryProxy {
    type Protocol = ObserverDiscoveryMarker;

    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 ObserverDiscoveryProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/ObserverDiscovery.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ObserverDiscoveryMarker 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) -> ObserverDiscoveryEventStream {
        ObserverDiscoveryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects a session watcher configured with the given options.
    pub fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        ObserverDiscoveryProxyInterface::r#watch_sessions(self, watch_options, sessions_watcher)
    }

    /// Connects to a `SessionObserver` for `session_id` if present. Drops the
    /// given channel otherwise.
    pub fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
    ) -> Result<(), fidl::Error> {
        ObserverDiscoveryProxyInterface::r#connect_to_session(self, session_id, session_request)
    }
}

impl ObserverDiscoveryProxyInterface for ObserverDiscoveryProxy {
    fn r#watch_sessions(
        &self,
        mut watch_options: &WatchOptions,
        mut sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ObserverDiscoveryWatchSessionsRequest>(
            (watch_options, sessions_watcher),
            0x3d95eaa20624a1fe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_to_session(
        &self,
        mut session_id: u64,
        mut session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ObserverDiscoveryConnectToSessionRequest>(
            (session_id, session_request),
            0x2c9b99aacfaac87a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/ObserverDiscovery.
pub struct ObserverDiscoveryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ObserverDiscoveryRequestStream {
    type Protocol = ObserverDiscoveryMarker;
    type ControlHandle = ObserverDiscoveryControlHandle;

    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 {
        ObserverDiscoveryControlHandle { 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 ObserverDiscoveryRequestStream {
    type Item = Result<ObserverDiscoveryRequest, 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 ObserverDiscoveryRequestStream 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 {
                    0x3d95eaa20624a1fe => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ObserverDiscoveryWatchSessionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ObserverDiscoveryWatchSessionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ObserverDiscoveryControlHandle { inner: this.inner.clone() };
                        Ok(ObserverDiscoveryRequest::WatchSessions {
                            watch_options: req.watch_options,
                            sessions_watcher: req.sessions_watcher,

                            control_handle,
                        })
                    }
                    0x2c9b99aacfaac87a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ObserverDiscoveryConnectToSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ObserverDiscoveryConnectToSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ObserverDiscoveryControlHandle { inner: this.inner.clone() };
                        Ok(ObserverDiscoveryRequest::ConnectToSession {
                            session_id: req.session_id,
                            session_request: req.session_request,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ObserverDiscoveryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `ObserverDiscovery` observes the collection of published media sessions
/// and connects clients to them for observation without playback controls.
#[derive(Debug)]
pub enum ObserverDiscoveryRequest {
    /// Connects a session watcher configured with the given options.
    WatchSessions {
        watch_options: WatchOptions,
        sessions_watcher: fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
        control_handle: ObserverDiscoveryControlHandle,
    },
    /// Connects to a `SessionObserver` for `session_id` if present. Drops the
    /// given channel otherwise.
    ConnectToSession {
        session_id: u64,
        session_request: fidl::endpoints::ServerEnd<SessionObserverMarker>,
        control_handle: ObserverDiscoveryControlHandle,
    },
}

impl ObserverDiscoveryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_sessions(
        self,
    ) -> Option<(
        WatchOptions,
        fidl::endpoints::ClientEnd<SessionsWatcherMarker>,
        ObserverDiscoveryControlHandle,
    )> {
        if let ObserverDiscoveryRequest::WatchSessions {
            watch_options,
            sessions_watcher,
            control_handle,
        } = self
        {
            Some((watch_options, sessions_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_session(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<SessionObserverMarker>,
        ObserverDiscoveryControlHandle,
    )> {
        if let ObserverDiscoveryRequest::ConnectToSession {
            session_id,
            session_request,
            control_handle,
        } = self
        {
            Some((session_id, session_request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ObserverDiscoveryRequest::WatchSessions { .. } => "watch_sessions",
            ObserverDiscoveryRequest::ConnectToSession { .. } => "connect_to_session",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for PlayerMarker {
    type Proxy = PlayerProxy;
    type RequestStream = PlayerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PlayerSynchronousProxy;

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

pub trait PlayerProxyInterface: Send + Sync {
    fn r#play(&self) -> Result<(), fidl::Error>;
    fn r#pause(&self) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
    fn r#seek(&self, position: i64) -> Result<(), fidl::Error>;
    fn r#skip_forward(&self) -> Result<(), fidl::Error>;
    fn r#skip_reverse(&self) -> Result<(), fidl::Error>;
    fn r#next_item(&self) -> Result<(), fidl::Error>;
    fn r#prev_item(&self) -> Result<(), fidl::Error>;
    fn r#set_playback_rate(&self, playback_rate: f32) -> Result<(), fidl::Error>;
    fn r#set_repeat_mode(&self, repeat_mode: RepeatMode) -> Result<(), fidl::Error>;
    fn r#set_shuffle_mode(&self, shuffle_on: bool) -> Result<(), fidl::Error>;
    fn r#bind_volume_control(
        &self,
        volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type WatchInfoChangeResponseFut: std::future::Future<Output = Result<PlayerInfoDelta, fidl::Error>>
        + Send;
    fn r#watch_info_change(&self) -> Self::WatchInfoChangeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PlayerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PlayerSynchronousProxy {
    type Proxy = PlayerProxy;
    type Protocol = PlayerMarker;

    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 PlayerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PlayerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x164120d5bdb26f8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x1536d16f202ece1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x1946e5fc6c2362ae,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSeekRequest>(
            (position,),
            0x4e7237d293e22125,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6ee04477076dac1b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xa4e05644ce33a28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x73307b32e35ff260,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x680444f03a759a3c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3831b8b161e1bccf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x21b9b1b17b7f01c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x7451a349ddb543c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x11d61e878cf808bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Gets the net player info change using the hanging get pattern.
    pub fn r#watch_info_change(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PlayerInfoDelta, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, PlayerWatchInfoChangeResponse>(
                (),
                0x69196e240c62a732,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.player_info_delta)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PlayerProxy {
    type Protocol = PlayerMarker;

    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 PlayerProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/Player.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PlayerMarker 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) -> PlayerEventStream {
        PlayerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#play(self)
    }

    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#pause(self)
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#stop(self)
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#seek(self, position)
    }

    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#skip_forward(self)
    }

    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#skip_reverse(self)
    }

    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#next_item(self)
    }

    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#prev_item(self)
    }

    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#set_playback_rate(self, playback_rate)
    }

    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#set_repeat_mode(self, repeat_mode)
    }

    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#set_shuffle_mode(self, shuffle_on)
    }

    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        PlayerProxyInterface::r#bind_volume_control(self, volume_control_request)
    }

    /// Gets the net player info change using the hanging get pattern.
    pub fn r#watch_info_change(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PlayerInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PlayerProxyInterface::r#watch_info_change(self)
    }
}

impl PlayerProxyInterface for PlayerProxy {
    fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x164120d5bdb26f8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSeekRequest>(
            (position,),
            0x4e7237d293e22125,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

    fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3831b8b161e1bccf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x21b9b1b17b7f01c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x7451a349ddb543c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x11d61e878cf808bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchInfoChangeResponseFut = fidl::client::QueryResponseFut<
        PlayerInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_info_change(&self) -> Self::WatchInfoChangeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PlayerInfoDelta, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PlayerWatchInfoChangeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x69196e240c62a732,
            >(_buf?)?;
            Ok(_response.player_info_delta)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PlayerInfoDelta>(
            (),
            0x69196e240c62a732,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/Player.
pub struct PlayerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PlayerRequestStream {
    type Protocol = PlayerMarker;
    type ControlHandle = PlayerControlHandle;

    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 {
        PlayerControlHandle { 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 PlayerRequestStream {
    type Item = Result<PlayerRequest, 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 PlayerRequestStream 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 {
                    0x164120d5bdb26f8e => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::Play { control_handle })
                    }
                    0x1536d16f202ece1 => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::Pause { control_handle })
                    }
                    0x1946e5fc6c2362ae => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::Stop { control_handle })
                    }
                    0x4e7237d293e22125 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSeekRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSeekRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::Seek { position: req.position, control_handle })
                    }
                    0x6ee04477076dac1b => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::SkipForward { control_handle })
                    }
                    0xa4e05644ce33a28 => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::SkipReverse { control_handle })
                    }
                    0x73307b32e35ff260 => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::NextItem { control_handle })
                    }
                    0x680444f03a759a3c => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::PrevItem { control_handle })
                    }
                    0x3831b8b161e1bccf => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetPlaybackRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetPlaybackRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::SetPlaybackRate {
                            playback_rate: req.playback_rate,

                            control_handle,
                        })
                    }
                    0x21b9b1b17b7f01c2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetRepeatModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetRepeatModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::SetRepeatMode {
                            repeat_mode: req.repeat_mode,

                            control_handle,
                        })
                    }
                    0x7451a349ddb543c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetShuffleModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetShuffleModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::SetShuffleMode {
                            shuffle_on: req.shuffle_on,

                            control_handle,
                        })
                    }
                    0x11d61e878cf808bc => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlBindVolumeControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlBindVolumeControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::BindVolumeControl {
                            volume_control_request: req.volume_control_request,

                            control_handle,
                        })
                    }
                    0x69196e240c62a732 => {
                        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 = PlayerControlHandle { inner: this.inner.clone() };
                        Ok(PlayerRequest::WatchInfoChange {
                            responder: PlayerWatchInfoChangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PlayerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `Player` is a handle for a media player. Unsupported commands are
/// no-ops.  Consult `PlaybackCapabilities`, sent by to learn which
/// commands are supported.
#[derive(Debug)]
pub enum PlayerRequest {
    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    Play { control_handle: PlayerControlHandle },
    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    Pause { control_handle: PlayerControlHandle },
    /// Stops playback. The session should close.
    Stop { control_handle: PlayerControlHandle },
    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    Seek { position: i64, control_handle: PlayerControlHandle },
    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    SkipForward { control_handle: PlayerControlHandle },
    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    SkipReverse { control_handle: PlayerControlHandle },
    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    NextItem { control_handle: PlayerControlHandle },
    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    PrevItem { control_handle: PlayerControlHandle },
    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    SetPlaybackRate { playback_rate: f32, control_handle: PlayerControlHandle },
    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    SetRepeatMode { repeat_mode: RepeatMode, control_handle: PlayerControlHandle },
    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    SetShuffleMode { shuffle_on: bool, control_handle: PlayerControlHandle },
    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    BindVolumeControl {
        volume_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: PlayerControlHandle,
    },
    /// Gets the net player info change using the hanging get pattern.
    WatchInfoChange { responder: PlayerWatchInfoChangeResponder },
}

impl PlayerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_play(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::Play { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pause(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::Pause { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_seek(self) -> Option<(i64, PlayerControlHandle)> {
        if let PlayerRequest::Seek { position, control_handle } = self {
            Some((position, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_forward(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::SkipForward { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_reverse(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::SkipReverse { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_next_item(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::NextItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_prev_item(self) -> Option<(PlayerControlHandle)> {
        if let PlayerRequest::PrevItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_playback_rate(self) -> Option<(f32, PlayerControlHandle)> {
        if let PlayerRequest::SetPlaybackRate { playback_rate, control_handle } = self {
            Some((playback_rate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_repeat_mode(self) -> Option<(RepeatMode, PlayerControlHandle)> {
        if let PlayerRequest::SetRepeatMode { repeat_mode, control_handle } = self {
            Some((repeat_mode, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_shuffle_mode(self) -> Option<(bool, PlayerControlHandle)> {
        if let PlayerRequest::SetShuffleMode { shuffle_on, control_handle } = self {
            Some((shuffle_on, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_volume_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        PlayerControlHandle,
    )> {
        if let PlayerRequest::BindVolumeControl { volume_control_request, control_handle } = self {
            Some((volume_control_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_info_change(self) -> Option<(PlayerWatchInfoChangeResponder)> {
        if let PlayerRequest::WatchInfoChange { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PlayerRequest::Play { .. } => "play",
            PlayerRequest::Pause { .. } => "pause",
            PlayerRequest::Stop { .. } => "stop",
            PlayerRequest::Seek { .. } => "seek",
            PlayerRequest::SkipForward { .. } => "skip_forward",
            PlayerRequest::SkipReverse { .. } => "skip_reverse",
            PlayerRequest::NextItem { .. } => "next_item",
            PlayerRequest::PrevItem { .. } => "prev_item",
            PlayerRequest::SetPlaybackRate { .. } => "set_playback_rate",
            PlayerRequest::SetRepeatMode { .. } => "set_repeat_mode",
            PlayerRequest::SetShuffleMode { .. } => "set_shuffle_mode",
            PlayerRequest::BindVolumeControl { .. } => "bind_volume_control",
            PlayerRequest::WatchInfoChange { .. } => "watch_info_change",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut player_info_delta: &PlayerInfoDelta) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PlayerWatchInfoChangeResponse>(
            (player_info_delta,),
            self.tx_id,
            0x69196e240c62a732,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PlayerControlMarker {
    type Proxy = PlayerControlProxy;
    type RequestStream = PlayerControlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PlayerControlSynchronousProxy;

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

pub trait PlayerControlProxyInterface: Send + Sync {
    fn r#play(&self) -> Result<(), fidl::Error>;
    fn r#pause(&self) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
    fn r#seek(&self, position: i64) -> Result<(), fidl::Error>;
    fn r#skip_forward(&self) -> Result<(), fidl::Error>;
    fn r#skip_reverse(&self) -> Result<(), fidl::Error>;
    fn r#next_item(&self) -> Result<(), fidl::Error>;
    fn r#prev_item(&self) -> Result<(), fidl::Error>;
    fn r#set_playback_rate(&self, playback_rate: f32) -> Result<(), fidl::Error>;
    fn r#set_repeat_mode(&self, repeat_mode: RepeatMode) -> Result<(), fidl::Error>;
    fn r#set_shuffle_mode(&self, shuffle_on: bool) -> Result<(), fidl::Error>;
    fn r#bind_volume_control(
        &self,
        volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PlayerControlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PlayerControlSynchronousProxy {
    type Proxy = PlayerControlProxy;
    type Protocol = PlayerControlMarker;

    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 PlayerControlSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PlayerControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x164120d5bdb26f8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x1536d16f202ece1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x1946e5fc6c2362ae,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSeekRequest>(
            (position,),
            0x4e7237d293e22125,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6ee04477076dac1b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xa4e05644ce33a28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x73307b32e35ff260,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x680444f03a759a3c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3831b8b161e1bccf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x21b9b1b17b7f01c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x7451a349ddb543c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x11d61e878cf808bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PlayerControlProxy {
    type Protocol = PlayerControlMarker;

    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 PlayerControlProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/PlayerControl.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PlayerControlMarker 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) -> PlayerControlEventStream {
        PlayerControlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#play(self)
    }

    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#pause(self)
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#stop(self)
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#seek(self, position)
    }

    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#skip_forward(self)
    }

    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#skip_reverse(self)
    }

    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#next_item(self)
    }

    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#prev_item(self)
    }

    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#set_playback_rate(self, playback_rate)
    }

    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#set_repeat_mode(self, repeat_mode)
    }

    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#set_shuffle_mode(self, shuffle_on)
    }

    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        PlayerControlProxyInterface::r#bind_volume_control(self, volume_control_request)
    }
}

impl PlayerControlProxyInterface for PlayerControlProxy {
    fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x164120d5bdb26f8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSeekRequest>(
            (position,),
            0x4e7237d293e22125,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

    fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3831b8b161e1bccf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x21b9b1b17b7f01c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x7451a349ddb543c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PlayerControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x11d61e878cf808bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/PlayerControl.
pub struct PlayerControlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PlayerControlRequestStream {
    type Protocol = PlayerControlMarker;
    type ControlHandle = PlayerControlControlHandle;

    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 {
        PlayerControlControlHandle { 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 PlayerControlRequestStream {
    type Item = Result<PlayerControlRequest, 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 PlayerControlRequestStream 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 {
                    0x164120d5bdb26f8e => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::Play { control_handle })
                    }
                    0x1536d16f202ece1 => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::Pause { control_handle })
                    }
                    0x1946e5fc6c2362ae => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::Stop { control_handle })
                    }
                    0x4e7237d293e22125 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSeekRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSeekRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::Seek { position: req.position, control_handle })
                    }
                    0x6ee04477076dac1b => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::SkipForward { control_handle })
                    }
                    0xa4e05644ce33a28 => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::SkipReverse { control_handle })
                    }
                    0x73307b32e35ff260 => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::NextItem { control_handle })
                    }
                    0x680444f03a759a3c => {
                        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 =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::PrevItem { control_handle })
                    }
                    0x3831b8b161e1bccf => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetPlaybackRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetPlaybackRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::SetPlaybackRate {
                            playback_rate: req.playback_rate,

                            control_handle,
                        })
                    }
                    0x21b9b1b17b7f01c2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetRepeatModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetRepeatModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::SetRepeatMode {
                            repeat_mode: req.repeat_mode,

                            control_handle,
                        })
                    }
                    0x7451a349ddb543c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlSetShuffleModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlSetShuffleModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::SetShuffleMode {
                            shuffle_on: req.shuffle_on,

                            control_handle,
                        })
                    }
                    0x11d61e878cf808bc => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PlayerControlBindVolumeControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PlayerControlBindVolumeControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PlayerControlControlHandle { inner: this.inner.clone() };
                        Ok(PlayerControlRequest::BindVolumeControl {
                            volume_control_request: req.volume_control_request,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PlayerControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Controls for a media player. `PlayerCapabilities` expresses which of the methods in this
/// protocol are supported by the player. Because capabilties are dynamic, and a client cannot
/// always know what capabilities will be supported when the method call reaches the service,
/// calling a method that is not supported is simply ignored. In general, clients should not
/// expect methods to work unless the player indicates sustained support.
#[derive(Debug)]
pub enum PlayerControlRequest {
    /// Plays media. If this method is not supported as indicated by the absence of the `PLAY`
    /// flag in `PlayerCapabilities`, this method does nothing.
    Play { control_handle: PlayerControlControlHandle },
    /// Pauses playback and retains position in media. If this method is not supported as indicated
    /// by the absence of the `PAUSE` flag in `PlayerCapabilities`, this method does nothing.
    Pause { control_handle: PlayerControlControlHandle },
    /// Stops playback. The session should close.
    Stop { control_handle: PlayerControlControlHandle },
    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media. If this method is not supported as indicated
    /// by the absence of the `SEEK` flag in `PlayerCapabilities`, this method does nothing.
    Seek { position: i64, control_handle: PlayerControlControlHandle },
    /// Skips forward in media by the player's default skip amount. If this method is not supported
    /// as indicated by the absence of the `SKIP_FORWARD` flag in `PlayerCapabilities`, this method
    /// does nothing.
    SkipForward { control_handle: PlayerControlControlHandle },
    /// Skips in reverse in media by the player's default skip amount. If this method is not
    /// supported as indicated by the absence of the `SKIP_REVERSE` flag in `PlayerCapabilities`,
    /// this method does nothing.
    SkipReverse { control_handle: PlayerControlControlHandle },
    /// Changes media to the next item (e.g. next song in playlist). If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_NEXT_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    NextItem { control_handle: PlayerControlControlHandle },
    /// Changes media to the previous item. If this method is not
    /// supported as indicated by the absence of the `CHANGE_TO_PREV_ITEM` flag in
    /// `PlayerCapabilities`, this method does nothing.
    PrevItem { control_handle: PlayerControlControlHandle },
    /// Sets the playback rate of the media. This will not change the playback mode. If this method
    /// is not supported as indicated by the absense of the `SET_PLAYBACK_RATE` flag in
    /// `PlayerCapabilities`, this method does nothing.
    SetPlaybackRate { playback_rate: f32, control_handle: PlayerControlControlHandle },
    /// Sets repeat mode to any of the supported repeat modes.
    /// Whether this method takes effect depends on the `PlayerCapabilities` and `repeat_mode`:
    ///   * [`OFF`] is always supported.
    ///   * [`GROUP`] requires the `REPEAT_GROUPS` capability, and is otherwise ignored.
    ///   * [`SINGLE`] requires the `REPEAT_SINGLE` capability, and is otherwise ignored.
    SetRepeatMode { repeat_mode: RepeatMode, control_handle: PlayerControlControlHandle },
    /// Sets shuffle mode. If this method is not supported as indicated by the absence of the
    /// `SHUFFLE` flag in `PlayerCapabilities`, this method does nothing.
    SetShuffleMode { shuffle_on: bool, control_handle: PlayerControlControlHandle },
    /// Binds to the session's volume control for control and notifications. If this method is not
    /// supported as indicated by the absence of the `HAS_GAIN_CONTROL` flag in
    /// `PlayerCapabilities`, the channel handle passed as `volume_control_request` is closed
    /// by the service.
    BindVolumeControl {
        volume_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: PlayerControlControlHandle,
    },
}

impl PlayerControlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_play(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::Play { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pause(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::Pause { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_seek(self) -> Option<(i64, PlayerControlControlHandle)> {
        if let PlayerControlRequest::Seek { position, control_handle } = self {
            Some((position, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_forward(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::SkipForward { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_reverse(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::SkipReverse { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_next_item(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::NextItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_prev_item(self) -> Option<(PlayerControlControlHandle)> {
        if let PlayerControlRequest::PrevItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_playback_rate(self) -> Option<(f32, PlayerControlControlHandle)> {
        if let PlayerControlRequest::SetPlaybackRate { playback_rate, control_handle } = self {
            Some((playback_rate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_repeat_mode(self) -> Option<(RepeatMode, PlayerControlControlHandle)> {
        if let PlayerControlRequest::SetRepeatMode { repeat_mode, control_handle } = self {
            Some((repeat_mode, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_shuffle_mode(self) -> Option<(bool, PlayerControlControlHandle)> {
        if let PlayerControlRequest::SetShuffleMode { shuffle_on, control_handle } = self {
            Some((shuffle_on, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_volume_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        PlayerControlControlHandle,
    )> {
        if let PlayerControlRequest::BindVolumeControl { volume_control_request, control_handle } =
            self
        {
            Some((volume_control_request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PlayerControlRequest::Play { .. } => "play",
            PlayerControlRequest::Pause { .. } => "pause",
            PlayerControlRequest::Stop { .. } => "stop",
            PlayerControlRequest::Seek { .. } => "seek",
            PlayerControlRequest::SkipForward { .. } => "skip_forward",
            PlayerControlRequest::SkipReverse { .. } => "skip_reverse",
            PlayerControlRequest::NextItem { .. } => "next_item",
            PlayerControlRequest::PrevItem { .. } => "prev_item",
            PlayerControlRequest::SetPlaybackRate { .. } => "set_playback_rate",
            PlayerControlRequest::SetRepeatMode { .. } => "set_repeat_mode",
            PlayerControlRequest::SetShuffleMode { .. } => "set_shuffle_mode",
            PlayerControlRequest::BindVolumeControl { .. } => "bind_volume_control",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for PublisherMarker {
    type Proxy = PublisherProxy;
    type RequestStream = PublisherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PublisherSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.sessions2.Publisher";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PublisherMarker {}

pub trait PublisherProxyInterface: Send + Sync {
    type PublishResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
    fn r#publish(
        &self,
        player: fidl::endpoints::ClientEnd<PlayerMarker>,
        registration: &PlayerRegistration,
    ) -> Self::PublishResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PublisherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PublisherSynchronousProxy {
    type Proxy = PublisherProxy;
    type Protocol = PublisherMarker;

    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 PublisherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PublisherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    pub fn r#publish(
        &self,
        mut player: fidl::endpoints::ClientEnd<PlayerMarker>,
        mut registration: &PlayerRegistration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u64, fidl::Error> {
        let _response =
            self.client.send_query::<PublisherPublishRequest, PublisherPublishResponse>(
                (player, registration),
                0x2e4a501ede5a1ad3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.session_id)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PublisherProxy {
    type Protocol = PublisherMarker;

    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 PublisherProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/Publisher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PublisherMarker 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) -> PublisherEventStream {
        PublisherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#publish(
        &self,
        mut player: fidl::endpoints::ClientEnd<PlayerMarker>,
        mut registration: &PlayerRegistration,
    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        PublisherProxyInterface::r#publish(self, player, registration)
    }
}

impl PublisherProxyInterface for PublisherProxy {
    type PublishResponseFut =
        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#publish(
        &self,
        mut player: fidl::endpoints::ClientEnd<PlayerMarker>,
        mut registration: &PlayerRegistration,
    ) -> Self::PublishResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PublisherPublishResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e4a501ede5a1ad3,
            >(_buf?)?;
            Ok(_response.session_id)
        }
        self.client.send_query_and_decode::<PublisherPublishRequest, u64>(
            (player, registration),
            0x2e4a501ede5a1ad3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/Publisher.
pub struct PublisherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PublisherRequestStream {
    type Protocol = PublisherMarker;
    type ControlHandle = PublisherControlHandle;

    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 {
        PublisherControlHandle { 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 PublisherRequestStream {
    type Item = Result<PublisherRequest, 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 PublisherRequestStream 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 {
                    0x2e4a501ede5a1ad3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PublisherPublishRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PublisherPublishRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PublisherControlHandle { inner: this.inner.clone() };
                        Ok(PublisherRequest::Publish {
                            player: req.player,
                            registration: req.registration,

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

/// `Publisher` publishes media players so they may be discovered and
/// controlled by clients who have permission to do so.
#[derive(Debug)]
pub enum PublisherRequest {
    Publish {
        player: fidl::endpoints::ClientEnd<PlayerMarker>,
        registration: PlayerRegistration,
        responder: PublisherPublishResponder,
    },
}

impl PublisherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_publish(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<PlayerMarker>,
        PlayerRegistration,
        PublisherPublishResponder,
    )> {
        if let PublisherRequest::Publish { player, registration, responder } = self {
            Some((player, registration, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut session_id: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PublisherPublishResponse>(
            (session_id,),
            self.tx_id,
            0x2e4a501ede5a1ad3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SessionControlMarker {
    type Proxy = SessionControlProxy;
    type RequestStream = SessionControlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionControlSynchronousProxy;

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

pub trait SessionControlProxyInterface: Send + Sync {
    fn r#play(&self) -> Result<(), fidl::Error>;
    fn r#pause(&self) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
    fn r#seek(&self, position: i64) -> Result<(), fidl::Error>;
    fn r#skip_forward(&self) -> Result<(), fidl::Error>;
    fn r#skip_reverse(&self) -> Result<(), fidl::Error>;
    fn r#next_item(&self) -> Result<(), fidl::Error>;
    fn r#prev_item(&self) -> Result<(), fidl::Error>;
    fn r#set_playback_rate(&self, playback_rate: f32) -> Result<(), fidl::Error>;
    fn r#set_repeat_mode(&self, repeat_mode: RepeatMode) -> Result<(), fidl::Error>;
    fn r#set_shuffle_mode(&self, shuffle_on: bool) -> Result<(), fidl::Error>;
    fn r#bind_volume_control(
        &self,
        volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type WatchStatusResponseFut: std::future::Future<Output = Result<SessionInfoDelta, fidl::Error>>
        + Send;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SessionControlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionControlSynchronousProxy {
    type Proxy = SessionControlProxy;
    type Protocol = SessionControlMarker;

    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 SessionControlSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SessionControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Plays media.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x43c91c558f7b2946,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Pauses playback and retains position in media
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x4e2d75c91ff7d22d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x53da6661beb2e817,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSeekRequest>(
            (position,),
            0x380280556aba53d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips forward in media by the player's default skip amount.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x3674bb00f0f12079,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Skips in reverse in media by the player's default skip amount.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5edc786c1a6b087c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the next item (e.g. next song in playlist).
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x13cab0e8bc316138,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Changes media to the previous item.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x7f7150e8bd6082cc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the playback rate of the media. This will not change the
    /// playback mode.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3e382e2b70c5121d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets repeat mode to any of the supported repeat modes.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x29381bedf7f29e5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets shuffle mode.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x34d8d4c0f35e89e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to the session's volume control for control and notifications.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x1e3c091a08e88710,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    pub fn r#watch_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionInfoDelta, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, SessionControlWatchStatusResponse>(
                (),
                0x4ce5727251eb4b74,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.session_info_delta)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SessionControlProxy {
    type Protocol = SessionControlMarker;

    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 SessionControlProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/SessionControl.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SessionControlMarker 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) -> SessionControlEventStream {
        SessionControlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Plays media.
    pub fn r#play(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#play(self)
    }

    /// Pauses playback and retains position in media
    pub fn r#pause(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#pause(self)
    }

    /// Stops playback. The session should close.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#stop(self)
    }

    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media.
    pub fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#seek(self, position)
    }

    /// Skips forward in media by the player's default skip amount.
    pub fn r#skip_forward(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#skip_forward(self)
    }

    /// Skips in reverse in media by the player's default skip amount.
    pub fn r#skip_reverse(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#skip_reverse(self)
    }

    /// Changes media to the next item (e.g. next song in playlist).
    pub fn r#next_item(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#next_item(self)
    }

    /// Changes media to the previous item.
    pub fn r#prev_item(&self) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#prev_item(self)
    }

    /// Sets the playback rate of the media. This will not change the
    /// playback mode.
    pub fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#set_playback_rate(self, playback_rate)
    }

    /// Sets repeat mode to any of the supported repeat modes.
    pub fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#set_repeat_mode(self, repeat_mode)
    }

    /// Sets shuffle mode.
    pub fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#set_shuffle_mode(self, shuffle_on)
    }

    /// Binds to the session's volume control for control and notifications.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        SessionControlProxyInterface::r#bind_volume_control(self, volume_control_request)
    }

    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    pub fn r#watch_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SessionInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionControlProxyInterface::r#watch_status(self)
    }
}

impl SessionControlProxyInterface for SessionControlProxy {
    fn r#play(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x43c91c558f7b2946,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#seek(&self, mut position: i64) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSeekRequest>(
            (position,),
            0x380280556aba53d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

    fn r#set_playback_rate(&self, mut playback_rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetPlaybackRateRequest>(
            (playback_rate,),
            0x3e382e2b70c5121d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_repeat_mode(&self, mut repeat_mode: RepeatMode) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetRepeatModeRequest>(
            (repeat_mode,),
            0x29381bedf7f29e5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_shuffle_mode(&self, mut shuffle_on: bool) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlSetShuffleModeRequest>(
            (shuffle_on,),
            0x34d8d4c0f35e89e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<SessionControlBindVolumeControlRequest>(
            (volume_control_request,),
            0x1e3c091a08e88710,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchStatusResponseFut = fidl::client::QueryResponseFut<
        SessionInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionInfoDelta, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SessionControlWatchStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4ce5727251eb4b74,
            >(_buf?)?;
            Ok(_response.session_info_delta)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SessionInfoDelta>(
            (),
            0x4ce5727251eb4b74,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/SessionControl.
pub struct SessionControlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SessionControlRequestStream {
    type Protocol = SessionControlMarker;
    type ControlHandle = SessionControlControlHandle;

    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 {
        SessionControlControlHandle { 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 SessionControlRequestStream {
    type Item = Result<SessionControlRequest, 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 SessionControlRequestStream 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 {
                    0x43c91c558f7b2946 => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::Play { control_handle })
                    }
                    0x4e2d75c91ff7d22d => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::Pause { control_handle })
                    }
                    0x53da6661beb2e817 => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::Stop { control_handle })
                    }
                    0x380280556aba53d4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SessionControlSeekRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionControlSeekRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::Seek { position: req.position, control_handle })
                    }
                    0x3674bb00f0f12079 => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::SkipForward { control_handle })
                    }
                    0x5edc786c1a6b087c => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::SkipReverse { control_handle })
                    }
                    0x13cab0e8bc316138 => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::NextItem { control_handle })
                    }
                    0x7f7150e8bd6082cc => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::PrevItem { control_handle })
                    }
                    0x3e382e2b70c5121d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SessionControlSetPlaybackRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionControlSetPlaybackRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::SetPlaybackRate {
                            playback_rate: req.playback_rate,

                            control_handle,
                        })
                    }
                    0x29381bedf7f29e5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SessionControlSetRepeatModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionControlSetRepeatModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::SetRepeatMode {
                            repeat_mode: req.repeat_mode,

                            control_handle,
                        })
                    }
                    0x34d8d4c0f35e89e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SessionControlSetShuffleModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionControlSetShuffleModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::SetShuffleMode {
                            shuffle_on: req.shuffle_on,

                            control_handle,
                        })
                    }
                    0x1e3c091a08e88710 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SessionControlBindVolumeControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionControlBindVolumeControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::BindVolumeControl {
                            volume_control_request: req.volume_control_request,

                            control_handle,
                        })
                    }
                    0x4ce5727251eb4b74 => {
                        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 =
                            SessionControlControlHandle { inner: this.inner.clone() };
                        Ok(SessionControlRequest::WatchStatus {
                            responder: SessionControlWatchStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SessionControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Controls a media session and views its status.
///
/// The channel will close if the media session is stopped.
#[derive(Debug)]
pub enum SessionControlRequest {
    /// Plays media.
    Play { control_handle: SessionControlControlHandle },
    /// Pauses playback and retains position in media
    Pause { control_handle: SessionControlControlHandle },
    /// Stops playback. The session should close.
    Stop { control_handle: SessionControlControlHandle },
    /// Seeks to a specific position in media. Implementations are free to
    /// enter an error state if the position is out of bounds. `position`
    /// is an offset from the beginning of the media.
    Seek { position: i64, control_handle: SessionControlControlHandle },
    /// Skips forward in media by the player's default skip amount.
    SkipForward { control_handle: SessionControlControlHandle },
    /// Skips in reverse in media by the player's default skip amount.
    SkipReverse { control_handle: SessionControlControlHandle },
    /// Changes media to the next item (e.g. next song in playlist).
    NextItem { control_handle: SessionControlControlHandle },
    /// Changes media to the previous item.
    PrevItem { control_handle: SessionControlControlHandle },
    /// Sets the playback rate of the media. This will not change the
    /// playback mode.
    SetPlaybackRate { playback_rate: f32, control_handle: SessionControlControlHandle },
    /// Sets repeat mode to any of the supported repeat modes.
    SetRepeatMode { repeat_mode: RepeatMode, control_handle: SessionControlControlHandle },
    /// Sets shuffle mode.
    SetShuffleMode { shuffle_on: bool, control_handle: SessionControlControlHandle },
    /// Binds to the session's volume control for control and notifications.
    BindVolumeControl {
        volume_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: SessionControlControlHandle,
    },
    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    WatchStatus { responder: SessionControlWatchStatusResponder },
}

impl SessionControlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_play(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::Play { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pause(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::Pause { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_seek(self) -> Option<(i64, SessionControlControlHandle)> {
        if let SessionControlRequest::Seek { position, control_handle } = self {
            Some((position, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_forward(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::SkipForward { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_skip_reverse(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::SkipReverse { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_next_item(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::NextItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_prev_item(self) -> Option<(SessionControlControlHandle)> {
        if let SessionControlRequest::PrevItem { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_playback_rate(self) -> Option<(f32, SessionControlControlHandle)> {
        if let SessionControlRequest::SetPlaybackRate { playback_rate, control_handle } = self {
            Some((playback_rate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_repeat_mode(self) -> Option<(RepeatMode, SessionControlControlHandle)> {
        if let SessionControlRequest::SetRepeatMode { repeat_mode, control_handle } = self {
            Some((repeat_mode, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_shuffle_mode(self) -> Option<(bool, SessionControlControlHandle)> {
        if let SessionControlRequest::SetShuffleMode { shuffle_on, control_handle } = self {
            Some((shuffle_on, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_volume_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        SessionControlControlHandle,
    )> {
        if let SessionControlRequest::BindVolumeControl { volume_control_request, control_handle } =
            self
        {
            Some((volume_control_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_status(self) -> Option<(SessionControlWatchStatusResponder)> {
        if let SessionControlRequest::WatchStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SessionControlRequest::Play { .. } => "play",
            SessionControlRequest::Pause { .. } => "pause",
            SessionControlRequest::Stop { .. } => "stop",
            SessionControlRequest::Seek { .. } => "seek",
            SessionControlRequest::SkipForward { .. } => "skip_forward",
            SessionControlRequest::SkipReverse { .. } => "skip_reverse",
            SessionControlRequest::NextItem { .. } => "next_item",
            SessionControlRequest::PrevItem { .. } => "prev_item",
            SessionControlRequest::SetPlaybackRate { .. } => "set_playback_rate",
            SessionControlRequest::SetRepeatMode { .. } => "set_repeat_mode",
            SessionControlRequest::SetShuffleMode { .. } => "set_shuffle_mode",
            SessionControlRequest::BindVolumeControl { .. } => "bind_volume_control",
            SessionControlRequest::WatchStatus { .. } => "watch_status",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut session_info_delta: &SessionInfoDelta) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SessionControlWatchStatusResponse>(
            (session_info_delta,),
            self.tx_id,
            0x4ce5727251eb4b74,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SessionObserverMarker {
    type Proxy = SessionObserverProxy;
    type RequestStream = SessionObserverRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionObserverSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionObserverSynchronousProxy {
    type Proxy = SessionObserverProxy;
    type Protocol = SessionObserverMarker;

    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 SessionObserverSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SessionObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    pub fn r#watch_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionInfoDelta, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, SessionObserverWatchStatusResponse>(
                (),
                0x24618b709ca18f4d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.session_info_delta)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SessionObserverProxy {
    type Protocol = SessionObserverMarker;

    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 SessionObserverProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/SessionObserver.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SessionObserverMarker 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) -> SessionObserverEventStream {
        SessionObserverEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    pub fn r#watch_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SessionInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionObserverProxyInterface::r#watch_status(self)
    }
}

impl SessionObserverProxyInterface for SessionObserverProxy {
    type WatchStatusResponseFut = fidl::client::QueryResponseFut<
        SessionInfoDelta,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionInfoDelta, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SessionObserverWatchStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24618b709ca18f4d,
            >(_buf?)?;
            Ok(_response.session_info_delta)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SessionInfoDelta>(
            (),
            0x24618b709ca18f4d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/SessionObserver.
pub struct SessionObserverRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SessionObserverRequestStream {
    type Protocol = SessionObserverMarker;
    type ControlHandle = SessionObserverControlHandle;

    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 {
        SessionObserverControlHandle { 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 SessionObserverRequestStream {
    type Item = Result<SessionObserverRequest, 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 SessionObserverRequestStream 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 {
                    0x24618b709ca18f4d => {
                        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 =
                            SessionObserverControlHandle { inner: this.inner.clone() };
                        Ok(SessionObserverRequest::WatchStatus {
                            responder: SessionObserverWatchStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SessionObserverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Views a media session's status.
///
/// The channel will close if the media session is stopped.
#[derive(Debug)]
pub enum SessionObserverRequest {
    /// Watches the session status. Leave a request hanging to receive a reply when
    /// the session status changes. The first request will be answered immediately with
    /// the current state.
    WatchStatus { responder: SessionObserverWatchStatusResponder },
}

impl SessionObserverRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_status(self) -> Option<(SessionObserverWatchStatusResponder)> {
        if let SessionObserverRequest::WatchStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut session_info_delta: &SessionInfoDelta) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SessionObserverWatchStatusResponse>(
            (session_info_delta,),
            self.tx_id,
            0x24618b709ca18f4d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SessionsWatcherMarker {
    type Proxy = SessionsWatcherProxy;
    type RequestStream = SessionsWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionsWatcherSynchronousProxy;

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

pub trait SessionsWatcherProxyInterface: Send + Sync {
    type SessionUpdatedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#session_updated(
        &self,
        session_id: u64,
        session_info_delta: &SessionInfoDelta,
    ) -> Self::SessionUpdatedResponseFut;
    type SessionRemovedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#session_removed(&self, session_id: u64) -> Self::SessionRemovedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SessionsWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionsWatcherSynchronousProxy {
    type Proxy = SessionsWatcherProxy;
    type Protocol = SessionsWatcherMarker;

    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 SessionsWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SessionsWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Called by the registry service when a session is updated. On first connection,
    /// this will be called as many times as needed to communicate the state of the
    /// world.
    ///
    /// `SessionsWatcher` must reply to acknowledge receipt of the session info delta.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    pub fn r#session_updated(
        &self,
        mut session_id: u64,
        mut session_info_delta: &SessionInfoDelta,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<SessionsWatcherSessionUpdatedRequest, fidl::encoding::EmptyPayload>(
                (session_id, session_info_delta),
                0x47d25ef93c58c2d9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Called by the registry service when a session is removed from the registered
    /// collection.
    ///
    /// `SessionsWatcher` must reply to acknlowledge receipt of the session removal.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    pub fn r#session_removed(
        &self,
        mut session_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<SessionsWatcherSessionRemovedRequest, fidl::encoding::EmptyPayload>(
                (session_id,),
                0x407556ecd5a2400e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SessionsWatcherProxy {
    type Protocol = SessionsWatcherMarker;

    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 SessionsWatcherProxy {
    /// Create a new Proxy for fuchsia.media.sessions2/SessionsWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SessionsWatcherMarker 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) -> SessionsWatcherEventStream {
        SessionsWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called by the registry service when a session is updated. On first connection,
    /// this will be called as many times as needed to communicate the state of the
    /// world.
    ///
    /// `SessionsWatcher` must reply to acknowledge receipt of the session info delta.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    pub fn r#session_updated(
        &self,
        mut session_id: u64,
        mut session_info_delta: &SessionInfoDelta,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        SessionsWatcherProxyInterface::r#session_updated(self, session_id, session_info_delta)
    }

    /// Called by the registry service when a session is removed from the registered
    /// collection.
    ///
    /// `SessionsWatcher` must reply to acknlowledge receipt of the session removal.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    pub fn r#session_removed(
        &self,
        mut session_id: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        SessionsWatcherProxyInterface::r#session_removed(self, session_id)
    }
}

impl SessionsWatcherProxyInterface for SessionsWatcherProxy {
    type SessionUpdatedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#session_updated(
        &self,
        mut session_id: u64,
        mut session_info_delta: &SessionInfoDelta,
    ) -> Self::SessionUpdatedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47d25ef93c58c2d9,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<SessionsWatcherSessionUpdatedRequest, ()>(
            (session_id, session_info_delta),
            0x47d25ef93c58c2d9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SessionRemovedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#session_removed(&self, mut session_id: u64) -> Self::SessionRemovedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x407556ecd5a2400e,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<SessionsWatcherSessionRemovedRequest, ()>(
            (session_id,),
            0x407556ecd5a2400e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.media.sessions2/SessionsWatcher.
pub struct SessionsWatcherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SessionsWatcherRequestStream {
    type Protocol = SessionsWatcherMarker;
    type ControlHandle = SessionsWatcherControlHandle;

    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 {
        SessionsWatcherControlHandle { 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 SessionsWatcherRequestStream {
    type Item = Result<SessionsWatcherRequest, 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 SessionsWatcherRequestStream 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 {
                    0x47d25ef93c58c2d9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionsWatcherSessionUpdatedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionsWatcherSessionUpdatedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionsWatcherControlHandle { inner: this.inner.clone() };
                        Ok(SessionsWatcherRequest::SessionUpdated {
                            session_id: req.session_id,
                            session_info_delta: req.session_info_delta,

                            responder: SessionsWatcherSessionUpdatedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x407556ecd5a2400e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionsWatcherSessionRemovedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionsWatcherSessionRemovedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SessionsWatcherControlHandle { inner: this.inner.clone() };
                        Ok(SessionsWatcherRequest::SessionRemoved {
                            session_id: req.session_id,

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

/// `SessionsWatcher` watches the collection of published sessions.
#[derive(Debug)]
pub enum SessionsWatcherRequest {
    /// Called by the registry service when a session is updated. On first connection,
    /// this will be called as many times as needed to communicate the state of the
    /// world.
    ///
    /// `SessionsWatcher` must reply to acknowledge receipt of the session info delta.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    SessionUpdated {
        session_id: u64,
        session_info_delta: SessionInfoDelta,
        responder: SessionsWatcherSessionUpdatedResponder,
    },
    /// Called by the registry service when a session is removed from the registered
    /// collection.
    ///
    /// `SessionsWatcher` must reply to acknlowledge receipt of the session removal.
    /// Delinquent watchers who do not reply will eventually be disconnected.
    SessionRemoved { session_id: u64, responder: SessionsWatcherSessionRemovedResponder },
}

impl SessionsWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_session_updated(
        self,
    ) -> Option<(u64, SessionInfoDelta, SessionsWatcherSessionUpdatedResponder)> {
        if let SessionsWatcherRequest::SessionUpdated {
            session_id,
            session_info_delta,
            responder,
        } = self
        {
            Some((session_id, session_info_delta, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_session_removed(self) -> Option<(u64, SessionsWatcherSessionRemovedResponder)> {
        if let SessionsWatcherRequest::SessionRemoved { session_id, responder } = self {
            Some((session_id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SessionsWatcherRequest::SessionUpdated { .. } => "session_updated",
            SessionsWatcherRequest::SessionRemoved { .. } => "session_removed",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;

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

    impl fidl::encoding::ResourceTypeMarker for DiscoveryConnectToSessionRequest {
        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 DiscoveryConnectToSessionRequest {
        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<
            DiscoveryConnectToSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DiscoveryConnectToSessionRequest
    {
        #[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::<DiscoveryConnectToSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DiscoveryConnectToSessionRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.session_id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionControlMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session_control_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionControlMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DiscoveryConnectToSessionRequest,
            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::<DiscoveryConnectToSessionRequest>(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 DiscoveryConnectToSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session_id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                session_control_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionControlMarker>>,
                    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!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionControlMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session_control_request,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DiscoveryWatchSessionsRequest {
        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 DiscoveryWatchSessionsRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            DiscoveryWatchSessionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DiscoveryWatchSessionsRequest
    {
        #[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::<DiscoveryWatchSessionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DiscoveryWatchSessionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <WatchOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.watch_options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<WatchOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DiscoveryWatchSessionsRequest,
            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::<DiscoveryWatchSessionsRequest>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DiscoveryWatchSessionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watch_options: fidl::new_empty!(
                    WatchOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                session_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                    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(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                WatchOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.watch_options,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session_watcher,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ObserverDiscoveryConnectToSessionRequest {
        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 ObserverDiscoveryConnectToSessionRequest {
        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<
            ObserverDiscoveryConnectToSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ObserverDiscoveryConnectToSessionRequest
    {
        #[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::<ObserverDiscoveryConnectToSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ObserverDiscoveryConnectToSessionRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.session_id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionObserverMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionObserverMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ObserverDiscoveryConnectToSessionRequest,
            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::<ObserverDiscoveryConnectToSessionRequest>(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 ObserverDiscoveryConnectToSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session_id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                session_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionObserverMarker>>,
                    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!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionObserverMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session_request,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ObserverDiscoveryWatchSessionsRequest {
        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 ObserverDiscoveryWatchSessionsRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            ObserverDiscoveryWatchSessionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ObserverDiscoveryWatchSessionsRequest
    {
        #[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::<ObserverDiscoveryWatchSessionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ObserverDiscoveryWatchSessionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <WatchOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.watch_options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.sessions_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<WatchOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ObserverDiscoveryWatchSessionsRequest,
            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::<ObserverDiscoveryWatchSessionsRequest>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ObserverDiscoveryWatchSessionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watch_options: fidl::new_empty!(
                    WatchOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                sessions_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                    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(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                WatchOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.watch_options,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SessionsWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.sessions_watcher,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for PublisherPublishRequest {
        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 PublisherPublishRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            PublisherPublishRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PublisherPublishRequest
    {
        #[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::<PublisherPublishRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PublisherPublishRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PlayerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.player),
                    <PlayerRegistration as fidl::encoding::ValueTypeMarker>::borrow(&self.registration),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PlayerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                PlayerRegistration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            PublisherPublishRequest,
            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::<PublisherPublishRequest>(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(0);
                (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 PublisherPublishRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                player: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PlayerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                registration: fidl::new_empty!(
                    PlayerRegistration,
                    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(0) };
            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 + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PlayerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.player,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                PlayerRegistration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.registration,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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