fidl_fuchsia_settings/

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

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

impl fidl::endpoints::ProtocolMarker for AccessibilityMarker {
    type Proxy = AccessibilityProxy;
    type RequestStream = AccessibilityRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessibilitySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Accessibility";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AccessibilityMarker {}
pub type AccessibilitySetResult = Result<(), Error>;

pub trait AccessibilityProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<AccessibilitySettings, fidl::Error>>
        + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<AccessibilitySetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &AccessibilitySettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessibilitySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessibilitySynchronousProxy {
    type Proxy = AccessibilityProxy;
    type Protocol = AccessibilityMarker;

    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 AccessibilitySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AccessibilityMarker 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<AccessibilityEvent, fidl::Error> {
        AccessibilityEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current value of all accessibility settings. Returns
    /// immediately on first call; subsequent calls return when any of the
    /// values change.
    ///
    /// - `settings` all current values of the accessibility settings.
    /// * see [`AccessibilitySettings`] for their meaning.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessibilitySettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, AccessibilityWatchResponse>(
                (),
                0x417d0b95ddbf7674,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets [AccessibilitySettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &AccessibilitySettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessibilitySetResult, fidl::Error> {
        let _response = self.client.send_query::<
            AccessibilitySetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x298485ef354fb8cb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AccessibilityProxy {
    type Protocol = AccessibilityMarker;

    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 AccessibilityProxy {
    /// Create a new Proxy for fuchsia.settings/Accessibility.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AccessibilityMarker 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) -> AccessibilityEventStream {
        AccessibilityEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current value of all accessibility settings. Returns
    /// immediately on first call; subsequent calls return when any of the
    /// values change.
    ///
    /// - `settings` all current values of the accessibility settings.
    /// * see [`AccessibilitySettings`] for their meaning.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AccessibilitySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessibilityProxyInterface::r#watch(self)
    }

    /// Sets [AccessibilitySettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &AccessibilitySettings,
    ) -> fidl::client::QueryResponseFut<
        AccessibilitySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessibilityProxyInterface::r#set(self, settings)
    }
}

impl AccessibilityProxyInterface for AccessibilityProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        AccessibilitySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessibilitySettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AccessibilityWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x417d0b95ddbf7674,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, AccessibilitySettings>(
            (),
            0x417d0b95ddbf7674,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        AccessibilitySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &AccessibilitySettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessibilitySetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x298485ef354fb8cb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AccessibilitySetRequest, AccessibilitySetResult>(
            (settings,),
            0x298485ef354fb8cb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Accessibility.
pub struct AccessibilityRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessibilityRequestStream {
    type Protocol = AccessibilityMarker;
    type ControlHandle = AccessibilityControlHandle;

    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 {
        AccessibilityControlHandle { 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 AccessibilityRequestStream {
    type Item = Result<AccessibilityRequest, 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 AccessibilityRequestStream 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 {
                    0x417d0b95ddbf7674 => {
                        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 =
                            AccessibilityControlHandle { inner: this.inner.clone() };
                        Ok(AccessibilityRequest::Watch {
                            responder: AccessibilityWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x298485ef354fb8cb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessibilitySetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessibilitySetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AccessibilityControlHandle { inner: this.inner.clone() };
                        Ok(AccessibilityRequest::Set {
                            settings: req.settings,

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

/// Modify or watch accessibility settings that are persisted.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum AccessibilityRequest {
    /// Gets the current value of all accessibility settings. Returns
    /// immediately on first call; subsequent calls return when any of the
    /// values change.
    ///
    /// - `settings` all current values of the accessibility settings.
    /// * see [`AccessibilitySettings`] for their meaning.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: AccessibilityWatchResponder },
    /// Sets [AccessibilitySettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    Set { settings: AccessibilitySettings, responder: AccessibilitySetResponder },
}

impl AccessibilityRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(AccessibilityWatchResponder)> {
        if let AccessibilityRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(AccessibilitySettings, AccessibilitySetResponder)> {
        if let AccessibilityRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AccessibilityRequest::Watch { .. } => "watch",
            AccessibilityRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &AccessibilitySettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AccessibilityWatchResponse>(
            (settings,),
            self.tx_id,
            0x417d0b95ddbf7674,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AudioMarker {
    type Proxy = AudioProxy;
    type RequestStream = AudioRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Audio";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioMarker {}
pub type AudioSetResult = Result<(), Error>;
pub type AudioSet2Result = Result<(), Error>;

pub trait AudioProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<AudioSettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type Watch2ResponseFut: std::future::Future<Output = Result<AudioSettings2, fidl::Error>> + Send;
    fn r#watch2(&self) -> Self::Watch2ResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<AudioSetResult, fidl::Error>> + Send;
    fn r#set(&self, settings: &AudioSettings) -> Self::SetResponseFut;
    type Set2ResponseFut: std::future::Future<Output = Result<AudioSet2Result, fidl::Error>> + Send;
    fn r#set2(&self, settings: &AudioSettings2) -> Self::Set2ResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioSynchronousProxy {
    type Proxy = AudioProxy;
    type Protocol = AudioMarker;

    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 AudioSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioMarker 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<AudioEvent, fidl::Error> {
        AudioEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [AudioSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<AudioSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, AudioWatchResponse>(
                (),
                0x2995cf83f9d0f805,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Gets the current [AudioSettings2]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    pub fn r#watch2(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AudioSettings2, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<AudioWatch2Response>,
        >(
            (),
            0x4d10b204de1796e2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<AudioMarker>("watch2")?;
        Ok(_response.settings)
    }

    /// Sets audio settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &AudioSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AudioSetResult, fidl::Error> {
        let _response = self.client.send_query::<AudioSetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings,),
            0x4f3865db04da626c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Sets audio settings. Only table fields that are set will lead to any changes; otherwise
    /// existing settings are unchanged.
    pub fn r#set2(
        &self,
        mut settings: &AudioSettings2,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AudioSet2Result, fidl::Error> {
        let _response = self.client.send_query::<
            AudioSet2Request,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x1f027e9ed7beefe3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<AudioMarker>("set2")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioProxy {
    type Protocol = AudioMarker;

    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 AudioProxy {
    /// Create a new Proxy for fuchsia.settings/Audio.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioMarker 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) -> AudioEventStream {
        AudioEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [AudioSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<AudioSettings, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioProxyInterface::r#watch(self)
    }

    /// Gets the current [AudioSettings2]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    pub fn r#watch2(
        &self,
    ) -> fidl::client::QueryResponseFut<AudioSettings2, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioProxyInterface::r#watch2(self)
    }

    /// Sets audio settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &AudioSettings,
    ) -> fidl::client::QueryResponseFut<AudioSetResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioProxyInterface::r#set(self, settings)
    }

    /// Sets audio settings. Only table fields that are set will lead to any changes; otherwise
    /// existing settings are unchanged.
    pub fn r#set2(
        &self,
        mut settings: &AudioSettings2,
    ) -> fidl::client::QueryResponseFut<
        AudioSet2Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AudioProxyInterface::r#set2(self, settings)
    }
}

impl AudioProxyInterface for AudioProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        AudioSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2995cf83f9d0f805,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, AudioSettings>(
            (),
            0x2995cf83f9d0f805,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type Watch2ResponseFut = fidl::client::QueryResponseFut<
        AudioSettings2,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch2(&self) -> Self::Watch2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioSettings2, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AudioWatch2Response>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4d10b204de1796e2,
            >(_buf?)?
            .into_result::<AudioMarker>("watch2")?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, AudioSettings2>(
            (),
            0x4d10b204de1796e2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        AudioSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &AudioSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4f3865db04da626c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AudioSetRequest, AudioSetResult>(
            (settings,),
            0x4f3865db04da626c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type Set2ResponseFut = fidl::client::QueryResponseFut<
        AudioSet2Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set2(&self, mut settings: &AudioSettings2) -> Self::Set2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioSet2Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f027e9ed7beefe3,
            >(_buf?)?
            .into_result::<AudioMarker>("set2")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AudioSet2Request, AudioSet2Result>(
            (settings,),
            0x1f027e9ed7beefe3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum AudioEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl AudioEvent {
    /// Decodes a message buffer as a [`AudioEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AudioEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(AudioEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <AudioMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.settings/Audio.
pub struct AudioRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AudioRequestStream {
    type Protocol = AudioMarker;
    type ControlHandle = AudioControlHandle;

    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 {
        AudioControlHandle { 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 AudioRequestStream {
    type Item = Result<AudioRequest, 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 AudioRequestStream 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 {
                    0x2995cf83f9d0f805 => {
                        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 = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::Watch {
                            responder: AudioWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4d10b204de1796e2 => {
                        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 = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::Watch2 {
                            responder: AudioWatch2Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4f3865db04da626c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::Set {
                            settings: req.settings,

                            responder: AudioSetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f027e9ed7beefe3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioSet2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioSet2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::Set2 {
                            settings: req.settings,

                            responder: AudioSet2Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AudioRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(AudioRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <AudioMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Settings related to audio.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum AudioRequest {
    /// Gets the current [AudioSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: AudioWatchResponder },
    /// Gets the current [AudioSettings2]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    Watch2 { responder: AudioWatch2Responder },
    /// Sets audio settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    Set { settings: AudioSettings, responder: AudioSetResponder },
    /// Sets audio settings. Only table fields that are set will lead to any changes; otherwise
    /// existing settings are unchanged.
    Set2 { settings: AudioSettings2, responder: AudioSet2Responder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: AudioControlHandle,
        method_type: fidl::MethodType,
    },
}

impl AudioRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(AudioWatchResponder)> {
        if let AudioRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch2(self) -> Option<(AudioWatch2Responder)> {
        if let AudioRequest::Watch2 { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(AudioSettings, AudioSetResponder)> {
        if let AudioRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set2(self) -> Option<(AudioSettings2, AudioSet2Responder)> {
        if let AudioRequest::Set2 { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioRequest::Watch { .. } => "watch",
            AudioRequest::Watch2 { .. } => "watch2",
            AudioRequest::Set { .. } => "set",
            AudioRequest::Set2 { .. } => "set2",
            AudioRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            AudioRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &AudioSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioWatchResponse>(
            (settings,),
            self.tx_id,
            0x2995cf83f9d0f805,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut settings: &AudioSettings2) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<AudioWatch2Response>>(
            fidl::encoding::Flexible::new((settings,)),
            self.tx_id,
            0x4d10b204de1796e2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x1f027e9ed7beefe3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DisplayMarker {
    type Proxy = DisplayProxy;
    type RequestStream = DisplayRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DisplaySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Display";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DisplayMarker {}
pub type DisplaySetResult = Result<(), Error>;

pub trait DisplayProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<DisplaySettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<DisplaySetResult, fidl::Error>> + Send;
    fn r#set(&self, settings: &DisplaySettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DisplaySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DisplaySynchronousProxy {
    type Proxy = DisplayProxy;
    type Protocol = DisplayMarker;

    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 DisplaySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DisplayMarker 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<DisplayEvent, fidl::Error> {
        DisplayEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [DisplaySettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplaySettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DisplayWatchResponse>(
                (),
                0x7da3212470364db1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets display settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &DisplaySettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplaySetResult, fidl::Error> {
        let _response = self.client.send_query::<DisplaySetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings,),
            0x1029e06ace17479c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DisplayProxy {
    type Protocol = DisplayMarker;

    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 DisplayProxy {
    /// Create a new Proxy for fuchsia.settings/Display.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DisplayMarker 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) -> DisplayEventStream {
        DisplayEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [DisplaySettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DisplaySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayProxyInterface::r#watch(self)
    }

    /// Sets display settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &DisplaySettings,
    ) -> fidl::client::QueryResponseFut<
        DisplaySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayProxyInterface::r#set(self, settings)
    }
}

impl DisplayProxyInterface for DisplayProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        DisplaySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DisplaySettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DisplayWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7da3212470364db1,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DisplaySettings>(
            (),
            0x7da3212470364db1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        DisplaySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &DisplaySettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DisplaySetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1029e06ace17479c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DisplaySetRequest, DisplaySetResult>(
            (settings,),
            0x1029e06ace17479c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Display.
pub struct DisplayRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DisplayRequestStream {
    type Protocol = DisplayMarker;
    type ControlHandle = DisplayControlHandle;

    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 {
        DisplayControlHandle { 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 DisplayRequestStream {
    type Item = Result<DisplayRequest, 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 DisplayRequestStream 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 {
                    0x7da3212470364db1 => {
                        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 = DisplayControlHandle { inner: this.inner.clone() };
                        Ok(DisplayRequest::Watch {
                            responder: DisplayWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1029e06ace17479c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DisplaySetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DisplaySetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DisplayControlHandle { inner: this.inner.clone() };
                        Ok(DisplayRequest::Set {
                            settings: req.settings,

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

/// Settings related to display.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum DisplayRequest {
    /// Gets the current [DisplaySettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: DisplayWatchResponder },
    /// Sets display settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    Set { settings: DisplaySettings, responder: DisplaySetResponder },
}

impl DisplayRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(DisplayWatchResponder)> {
        if let DisplayRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(DisplaySettings, DisplaySetResponder)> {
        if let DisplayRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DisplayRequest::Watch { .. } => "watch",
            DisplayRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &DisplaySettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DisplayWatchResponse>(
            (settings,),
            self.tx_id,
            0x7da3212470364db1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DoNotDisturbMarker {
    type Proxy = DoNotDisturbProxy;
    type RequestStream = DoNotDisturbRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DoNotDisturbSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.DoNotDisturb";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DoNotDisturbMarker {}
pub type DoNotDisturbSetResult = Result<(), Error>;

pub trait DoNotDisturbProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<DoNotDisturbSettings, fidl::Error>>
        + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<DoNotDisturbSetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &DoNotDisturbSettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DoNotDisturbSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DoNotDisturbSynchronousProxy {
    type Proxy = DoNotDisturbProxy;
    type Protocol = DoNotDisturbMarker;

    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 DoNotDisturbSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DoNotDisturbMarker 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<DoNotDisturbEvent, fidl::Error> {
        DoNotDisturbEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [`DoNotDisturbSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DoNotDisturbSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DoNotDisturbWatchResponse>(
                (),
                0x1eeae2f97a5547fb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets [`DoNotDisturbSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &DoNotDisturbSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DoNotDisturbSetResult, fidl::Error> {
        let _response = self.client.send_query::<
            DoNotDisturbSetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x7fef934e7f5777b0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DoNotDisturbProxy {
    type Protocol = DoNotDisturbMarker;

    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 DoNotDisturbProxy {
    /// Create a new Proxy for fuchsia.settings/DoNotDisturb.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DoNotDisturbMarker 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) -> DoNotDisturbEventStream {
        DoNotDisturbEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [`DoNotDisturbSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DoNotDisturbSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DoNotDisturbProxyInterface::r#watch(self)
    }

    /// Sets [`DoNotDisturbSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &DoNotDisturbSettings,
    ) -> fidl::client::QueryResponseFut<
        DoNotDisturbSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DoNotDisturbProxyInterface::r#set(self, settings)
    }
}

impl DoNotDisturbProxyInterface for DoNotDisturbProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        DoNotDisturbSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DoNotDisturbSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DoNotDisturbWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1eeae2f97a5547fb,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DoNotDisturbSettings>(
            (),
            0x1eeae2f97a5547fb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        DoNotDisturbSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &DoNotDisturbSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DoNotDisturbSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7fef934e7f5777b0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DoNotDisturbSetRequest, DoNotDisturbSetResult>(
            (settings,),
            0x7fef934e7f5777b0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/DoNotDisturb.
pub struct DoNotDisturbRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DoNotDisturbRequestStream {
    type Protocol = DoNotDisturbMarker;
    type ControlHandle = DoNotDisturbControlHandle;

    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 {
        DoNotDisturbControlHandle { 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 DoNotDisturbRequestStream {
    type Item = Result<DoNotDisturbRequest, 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 DoNotDisturbRequestStream 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 {
                    0x1eeae2f97a5547fb => {
                        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 =
                            DoNotDisturbControlHandle { inner: this.inner.clone() };
                        Ok(DoNotDisturbRequest::Watch {
                            responder: DoNotDisturbWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7fef934e7f5777b0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DoNotDisturbSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DoNotDisturbSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DoNotDisturbControlHandle { inner: this.inner.clone() };
                        Ok(DoNotDisturbRequest::Set {
                            settings: req.settings,

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

/// Modify or watch do-not-disturb (DND) mode. While DND is active, distractions
/// created by the device are reduced or eliminated. E.g. bootup is silent,
/// incoming calls could be rejected or silent, and notifications could be
/// paused, silent, or hidden. High-priority disruptions like alarms can be
/// allowed.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum DoNotDisturbRequest {
    /// Gets the current [`DoNotDisturbSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: DoNotDisturbWatchResponder },
    /// Sets [`DoNotDisturbSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    Set { settings: DoNotDisturbSettings, responder: DoNotDisturbSetResponder },
}

impl DoNotDisturbRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(DoNotDisturbWatchResponder)> {
        if let DoNotDisturbRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(DoNotDisturbSettings, DoNotDisturbSetResponder)> {
        if let DoNotDisturbRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DoNotDisturbRequest::Watch { .. } => "watch",
            DoNotDisturbRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &DoNotDisturbSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DoNotDisturbWatchResponse>(
            (settings,),
            self.tx_id,
            0x1eeae2f97a5547fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for FactoryResetMarker {
    type Proxy = FactoryResetProxy;
    type RequestStream = FactoryResetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FactoryResetSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.FactoryReset";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FactoryResetMarker {}
pub type FactoryResetSetResult = Result<(), Error>;

pub trait FactoryResetProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<FactoryResetSettings, fidl::Error>>
        + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<FactoryResetSetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &FactoryResetSettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FactoryResetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FactoryResetSynchronousProxy {
    type Proxy = FactoryResetProxy;
    type Protocol = FactoryResetMarker;

    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 FactoryResetSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <FactoryResetMarker 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<FactoryResetEvent, fidl::Error> {
        FactoryResetEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Notifies of a change in information about the factory reset settings.
    ///
    /// On a given connection, the first call will return the current `settings`
    /// value while subsequent calls will only return the new `settings` value
    /// upon a value change. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will
    /// be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FactoryResetSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, FactoryResetWatchResponse>(
                (),
                0x50cfc9906eb406a1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets factory reset settings. Any field not explicitly set in the table
    /// performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &FactoryResetSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FactoryResetSetResult, fidl::Error> {
        let _response = self.client.send_query::<
            FactoryResetSetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x5b35942c1cb1eca8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FactoryResetProxy {
    type Protocol = FactoryResetMarker;

    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 FactoryResetProxy {
    /// Create a new Proxy for fuchsia.settings/FactoryReset.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FactoryResetMarker 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) -> FactoryResetEventStream {
        FactoryResetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Notifies of a change in information about the factory reset settings.
    ///
    /// On a given connection, the first call will return the current `settings`
    /// value while subsequent calls will only return the new `settings` value
    /// upon a value change. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will
    /// be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        FactoryResetSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FactoryResetProxyInterface::r#watch(self)
    }

    /// Sets factory reset settings. Any field not explicitly set in the table
    /// performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &FactoryResetSettings,
    ) -> fidl::client::QueryResponseFut<
        FactoryResetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FactoryResetProxyInterface::r#set(self, settings)
    }
}

impl FactoryResetProxyInterface for FactoryResetProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        FactoryResetSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FactoryResetSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FactoryResetWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50cfc9906eb406a1,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, FactoryResetSettings>(
            (),
            0x50cfc9906eb406a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        FactoryResetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &FactoryResetSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FactoryResetSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b35942c1cb1eca8,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FactoryResetSetRequest, FactoryResetSetResult>(
            (settings,),
            0x5b35942c1cb1eca8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/FactoryReset.
pub struct FactoryResetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for FactoryResetRequestStream {
    type Protocol = FactoryResetMarker;
    type ControlHandle = FactoryResetControlHandle;

    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 {
        FactoryResetControlHandle { 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 FactoryResetRequestStream {
    type Item = Result<FactoryResetRequest, 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 FactoryResetRequestStream 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 {
                    0x50cfc9906eb406a1 => {
                        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 =
                            FactoryResetControlHandle { inner: this.inner.clone() };
                        Ok(FactoryResetRequest::Watch {
                            responder: FactoryResetWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b35942c1cb1eca8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FactoryResetSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FactoryResetSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FactoryResetControlHandle { inner: this.inner.clone() };
                        Ok(FactoryResetRequest::Set {
                            settings: req.settings,

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

/// Settings related to factory reset.
#[derive(Debug)]
pub enum FactoryResetRequest {
    /// Notifies of a change in information about the factory reset settings.
    ///
    /// On a given connection, the first call will return the current `settings`
    /// value while subsequent calls will only return the new `settings` value
    /// upon a value change. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will
    /// be closed.
    Watch { responder: FactoryResetWatchResponder },
    /// Sets factory reset settings. Any field not explicitly set in the table
    /// performs a no-op, and will not make any changes.
    Set { settings: FactoryResetSettings, responder: FactoryResetSetResponder },
}

impl FactoryResetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(FactoryResetWatchResponder)> {
        if let FactoryResetRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(FactoryResetSettings, FactoryResetSetResponder)> {
        if let FactoryResetRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FactoryResetRequest::Watch { .. } => "watch",
            FactoryResetRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &FactoryResetSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FactoryResetWatchResponse>(
            (settings,),
            self.tx_id,
            0x50cfc9906eb406a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for InputMarker {
    type Proxy = InputProxy;
    type RequestStream = InputRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = InputSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Input";
}
impl fidl::endpoints::DiscoverableProtocolMarker for InputMarker {}
pub type InputSetResult = Result<(), Error>;

pub trait InputProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<InputSettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<InputSetResult, fidl::Error>> + Send;
    fn r#set(&self, input_states: &[InputState]) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct InputSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for InputSynchronousProxy {
    type Proxy = InputProxy;
    type Protocol = InputMarker;

    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 InputSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <InputMarker 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<InputEvent, fidl::Error> {
        InputEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current |InputSettings|. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// When any of the input devices' states change, this will return the
    /// full [InputSettings] object, containing the states for all the
    /// available input devices on the target device.
    ///
    /// To find the state of a specific input device, the devices vector
    /// contained in settings can be iterated through to find a specific
    /// [DeviceType]. If there are multiple devices of the same [DeviceType],
    /// the [InputDevice]'s device_name can be examined in conjunction with
    /// the [DeviceType] to find the desired input device. Together, the
    /// device_name and [DeviceType] uniquely identify an [InputDevice].
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<InputSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, InputWatchResponse>(
                (),
                0x1bc41a7e0edd19c9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Requests software input devices to set their software state. May
    /// not necessarily change the overall state of the device, depending on
    /// the hardware state. Will modify the software state of the existing
    /// device if a known device_name and device_type are passed. Otherwise
    /// it will add a new input device. Devices not included in input_states
    /// will not be modified.
    pub fn r#set(
        &self,
        mut input_states: &[InputState],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<InputSetResult, fidl::Error> {
        let _response = self.client.send_query::<InputSetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (input_states,),
            0x2447379e693141ca,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for InputProxy {
    type Protocol = InputMarker;

    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 InputProxy {
    /// Create a new Proxy for fuchsia.settings/Input.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <InputMarker 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) -> InputEventStream {
        InputEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current |InputSettings|. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// When any of the input devices' states change, this will return the
    /// full [InputSettings] object, containing the states for all the
    /// available input devices on the target device.
    ///
    /// To find the state of a specific input device, the devices vector
    /// contained in settings can be iterated through to find a specific
    /// [DeviceType]. If there are multiple devices of the same [DeviceType],
    /// the [InputDevice]'s device_name can be examined in conjunction with
    /// the [DeviceType] to find the desired input device. Together, the
    /// device_name and [DeviceType] uniquely identify an [InputDevice].
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<InputSettings, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        InputProxyInterface::r#watch(self)
    }

    /// Requests software input devices to set their software state. May
    /// not necessarily change the overall state of the device, depending on
    /// the hardware state. Will modify the software state of the existing
    /// device if a known device_name and device_type are passed. Otherwise
    /// it will add a new input device. Devices not included in input_states
    /// will not be modified.
    pub fn r#set(
        &self,
        mut input_states: &[InputState],
    ) -> fidl::client::QueryResponseFut<InputSetResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        InputProxyInterface::r#set(self, input_states)
    }
}

impl InputProxyInterface for InputProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        InputSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InputSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                InputWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1bc41a7e0edd19c9,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, InputSettings>(
            (),
            0x1bc41a7e0edd19c9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        InputSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut input_states: &[InputState]) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InputSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2447379e693141ca,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<InputSetRequest, InputSetResult>(
            (input_states,),
            0x2447379e693141ca,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Input.
pub struct InputRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for InputRequestStream {
    type Protocol = InputMarker;
    type ControlHandle = InputControlHandle;

    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 {
        InputControlHandle { 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 InputRequestStream {
    type Item = Result<InputRequest, 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 InputRequestStream 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 {
                    0x1bc41a7e0edd19c9 => {
                        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 = InputControlHandle { inner: this.inner.clone() };
                        Ok(InputRequest::Watch {
                            responder: InputWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2447379e693141ca => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            InputSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<InputSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = InputControlHandle { inner: this.inner.clone() };
                        Ok(InputRequest::Set {
                            input_states: req.input_states,

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

/// Settings related to input to the device.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum InputRequest {
    /// Gets the current |InputSettings|. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// When any of the input devices' states change, this will return the
    /// full [InputSettings] object, containing the states for all the
    /// available input devices on the target device.
    ///
    /// To find the state of a specific input device, the devices vector
    /// contained in settings can be iterated through to find a specific
    /// [DeviceType]. If there are multiple devices of the same [DeviceType],
    /// the [InputDevice]'s device_name can be examined in conjunction with
    /// the [DeviceType] to find the desired input device. Together, the
    /// device_name and [DeviceType] uniquely identify an [InputDevice].
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: InputWatchResponder },
    /// Requests software input devices to set their software state. May
    /// not necessarily change the overall state of the device, depending on
    /// the hardware state. Will modify the software state of the existing
    /// device if a known device_name and device_type are passed. Otherwise
    /// it will add a new input device. Devices not included in input_states
    /// will not be modified.
    Set { input_states: Vec<InputState>, responder: InputSetResponder },
}

impl InputRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(InputWatchResponder)> {
        if let InputRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(Vec<InputState>, InputSetResponder)> {
        if let InputRequest::Set { input_states, responder } = self {
            Some((input_states, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            InputRequest::Watch { .. } => "watch",
            InputRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &InputSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<InputWatchResponse>(
            (settings,),
            self.tx_id,
            0x1bc41a7e0edd19c9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for IntlMarker {
    type Proxy = IntlProxy;
    type RequestStream = IntlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = IntlSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Intl";
}
impl fidl::endpoints::DiscoverableProtocolMarker for IntlMarker {}
pub type IntlSetResult = Result<(), Error>;

pub trait IntlProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<IntlSettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<IntlSetResult, fidl::Error>> + Send;
    fn r#set(&self, settings: &IntlSettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct IntlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for IntlSynchronousProxy {
    type Proxy = IntlProxy;
    type Protocol = IntlMarker;

    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 IntlSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <IntlMarker 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<IntlEvent, fidl::Error> {
        IntlEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [IntlSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<IntlSettings, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, IntlWatchResponse>(
            (),
            0x3c85d6b8a85ab6e3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.settings)
    }

    /// Sets [IntlSettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &IntlSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<IntlSetResult, fidl::Error> {
        let _response = self.client.send_query::<IntlSetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings,),
            0x273014eb4d880c5a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for IntlProxy {
    type Protocol = IntlMarker;

    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 IntlProxy {
    /// Create a new Proxy for fuchsia.settings/Intl.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <IntlMarker 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) -> IntlEventStream {
        IntlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [IntlSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<IntlSettings, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        IntlProxyInterface::r#watch(self)
    }

    /// Sets [IntlSettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &IntlSettings,
    ) -> fidl::client::QueryResponseFut<IntlSetResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        IntlProxyInterface::r#set(self, settings)
    }
}

impl IntlProxyInterface for IntlProxy {
    type WatchResponseFut =
        fidl::client::QueryResponseFut<IntlSettings, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IntlSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                IntlWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3c85d6b8a85ab6e3,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, IntlSettings>(
            (),
            0x3c85d6b8a85ab6e3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        IntlSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &IntlSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IntlSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x273014eb4d880c5a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<IntlSetRequest, IntlSetResult>(
            (settings,),
            0x273014eb4d880c5a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Intl.
pub struct IntlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for IntlRequestStream {
    type Protocol = IntlMarker;
    type ControlHandle = IntlControlHandle;

    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 {
        IntlControlHandle { 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 IntlRequestStream {
    type Item = Result<IntlRequest, 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 IntlRequestStream 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 {
                    0x3c85d6b8a85ab6e3 => {
                        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 = IntlControlHandle { inner: this.inner.clone() };
                        Ok(IntlRequest::Watch {
                            responder: IntlWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x273014eb4d880c5a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            IntlSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<IntlSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = IntlControlHandle { inner: this.inner.clone() };
                        Ok(IntlRequest::Set {
                            settings: req.settings,

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

/// Settings related to internationalization such as locale, time zone, and
/// temperature units.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR,
/// FILE_READ_ERROR
#[derive(Debug)]
pub enum IntlRequest {
    /// Gets the current [IntlSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: IntlWatchResponder },
    /// Sets [IntlSettings] settings. Any field not explicitly set in the table performs a
    /// no-op, and will not make any changes.
    Set { settings: IntlSettings, responder: IntlSetResponder },
}

impl IntlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(IntlWatchResponder)> {
        if let IntlRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(IntlSettings, IntlSetResponder)> {
        if let IntlRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            IntlRequest::Watch { .. } => "watch",
            IntlRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &IntlSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<IntlWatchResponse>(
            (settings,),
            self.tx_id,
            0x3c85d6b8a85ab6e3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for KeyboardMarker {
    type Proxy = KeyboardProxy;
    type RequestStream = KeyboardRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = KeyboardSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Keyboard";
}
impl fidl::endpoints::DiscoverableProtocolMarker for KeyboardMarker {}

pub trait KeyboardProxyInterface: Send + Sync {
    type SetResponseFut: std::future::Future<Output = Result<KeyboardSetSetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &KeyboardSettings) -> Self::SetResponseFut;
    type WatchResponseFut: std::future::Future<Output = Result<KeyboardSettings, fidl::Error>>
        + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct KeyboardSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for KeyboardSynchronousProxy {
    type Proxy = KeyboardProxy;
    type Protocol = KeyboardMarker;

    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 KeyboardSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <KeyboardMarker 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<KeyboardEvent, fidl::Error> {
        KeyboardEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    pub fn r#set(
        &self,
        mut settings: &KeyboardSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<KeyboardSetSetResult, fidl::Error> {
        let _response = self.client.send_query::<
            KeyboardSetSetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x691f4493d263c843,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<KeyboardSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, KeyboardWatchWatchResponse>(
                (),
                0x357f6213b3a54527,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for KeyboardProxy {
    type Protocol = KeyboardMarker;

    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 KeyboardProxy {
    /// Create a new Proxy for fuchsia.settings/Keyboard.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <KeyboardMarker 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) -> KeyboardEventStream {
        KeyboardEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    pub fn r#set(
        &self,
        mut settings: &KeyboardSettings,
    ) -> fidl::client::QueryResponseFut<
        KeyboardSetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        KeyboardProxyInterface::r#set(self, settings)
    }

    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        KeyboardSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        KeyboardProxyInterface::r#watch(self)
    }
}

impl KeyboardProxyInterface for KeyboardProxy {
    type SetResponseFut = fidl::client::QueryResponseFut<
        KeyboardSetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &KeyboardSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<KeyboardSetSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x691f4493d263c843,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<KeyboardSetSetRequest, KeyboardSetSetResult>(
            (settings,),
            0x691f4493d263c843,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchResponseFut = fidl::client::QueryResponseFut<
        KeyboardSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<KeyboardSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                KeyboardWatchWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x357f6213b3a54527,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, KeyboardSettings>(
            (),
            0x357f6213b3a54527,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Keyboard.
pub struct KeyboardRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for KeyboardRequestStream {
    type Protocol = KeyboardMarker;
    type ControlHandle = KeyboardControlHandle;

    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 {
        KeyboardControlHandle { 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 KeyboardRequestStream {
    type Item = Result<KeyboardRequest, 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 KeyboardRequestStream 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 {
                    0x691f4493d263c843 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            KeyboardSetSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<KeyboardSetSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = KeyboardControlHandle { inner: this.inner.clone() };
                        Ok(KeyboardRequest::Set {
                            settings: req.settings,

                            responder: KeyboardSetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x357f6213b3a54527 => {
                        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 = KeyboardControlHandle { inner: this.inner.clone() };
                        Ok(KeyboardRequest::Watch {
                            responder: KeyboardWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <KeyboardMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The SetUI protocol for reading and modifying the keyboard settings.
#[derive(Debug)]
pub enum KeyboardRequest {
    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    Set { settings: KeyboardSettings, responder: KeyboardSetResponder },
    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    Watch { responder: KeyboardWatchResponder },
}

impl KeyboardRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(KeyboardSettings, KeyboardSetResponder)> {
        if let KeyboardRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(KeyboardWatchResponder)> {
        if let KeyboardRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            KeyboardRequest::Set { .. } => "set",
            KeyboardRequest::Watch { .. } => "watch",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut settings: &KeyboardSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<KeyboardWatchWatchResponse>(
            (settings,),
            self.tx_id,
            0x357f6213b3a54527,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for KeyboardSetMarker {
    type Proxy = KeyboardSetProxy;
    type RequestStream = KeyboardSetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = KeyboardSetSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) KeyboardSet";
}
pub type KeyboardSetSetResult = Result<(), Error>;

pub trait KeyboardSetProxyInterface: Send + Sync {
    type SetResponseFut: std::future::Future<Output = Result<KeyboardSetSetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &KeyboardSettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct KeyboardSetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for KeyboardSetSynchronousProxy {
    type Proxy = KeyboardSetProxy;
    type Protocol = KeyboardSetMarker;

    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 KeyboardSetSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <KeyboardSetMarker 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<KeyboardSetEvent, fidl::Error> {
        KeyboardSetEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    pub fn r#set(
        &self,
        mut settings: &KeyboardSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<KeyboardSetSetResult, fidl::Error> {
        let _response = self.client.send_query::<
            KeyboardSetSetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (settings,),
            0x691f4493d263c843,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for KeyboardSetProxy {
    type Protocol = KeyboardSetMarker;

    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 KeyboardSetProxy {
    /// Create a new Proxy for fuchsia.settings/KeyboardSet.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <KeyboardSetMarker 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) -> KeyboardSetEventStream {
        KeyboardSetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    pub fn r#set(
        &self,
        mut settings: &KeyboardSettings,
    ) -> fidl::client::QueryResponseFut<
        KeyboardSetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        KeyboardSetProxyInterface::r#set(self, settings)
    }
}

impl KeyboardSetProxyInterface for KeyboardSetProxy {
    type SetResponseFut = fidl::client::QueryResponseFut<
        KeyboardSetSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &KeyboardSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<KeyboardSetSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x691f4493d263c843,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<KeyboardSetSetRequest, KeyboardSetSetResult>(
            (settings,),
            0x691f4493d263c843,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/KeyboardSet.
pub struct KeyboardSetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for KeyboardSetRequestStream {
    type Protocol = KeyboardSetMarker;
    type ControlHandle = KeyboardSetControlHandle;

    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 {
        KeyboardSetControlHandle { 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 KeyboardSetRequestStream {
    type Item = Result<KeyboardSetRequest, 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 KeyboardSetRequestStream 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 {
                    0x691f4493d263c843 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            KeyboardSetSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<KeyboardSetSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = KeyboardSetControlHandle { inner: this.inner.clone() };
                        Ok(KeyboardSetRequest::Set {
                            settings: req.settings,

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

/// The mutable API for modifying the keyboard settings.
#[derive(Debug)]
pub enum KeyboardSetRequest {
    /// Setting protocol: if a field is left unset, it is not modified.
    /// To clear a field, set it to its type's "zero" value.
    Set { settings: KeyboardSettings, responder: KeyboardSetSetResponder },
}

impl KeyboardSetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(KeyboardSettings, KeyboardSetSetResponder)> {
        if let KeyboardSetRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for KeyboardWatchMarker {
    type Proxy = KeyboardWatchProxy;
    type RequestStream = KeyboardWatchRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = KeyboardWatchSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for KeyboardWatchSynchronousProxy {
    type Proxy = KeyboardWatchProxy;
    type Protocol = KeyboardWatchMarker;

    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 KeyboardWatchSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <KeyboardWatchMarker 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<KeyboardWatchEvent, fidl::Error> {
        KeyboardWatchEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<KeyboardSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, KeyboardWatchWatchResponse>(
                (),
                0x357f6213b3a54527,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for KeyboardWatchProxy {
    type Protocol = KeyboardWatchMarker;

    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 KeyboardWatchProxy {
    /// Create a new Proxy for fuchsia.settings/KeyboardWatch.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <KeyboardWatchMarker 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) -> KeyboardWatchEventStream {
        KeyboardWatchEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        KeyboardSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        KeyboardWatchProxyInterface::r#watch(self)
    }
}

impl KeyboardWatchProxyInterface for KeyboardWatchProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        KeyboardSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<KeyboardSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                KeyboardWatchWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x357f6213b3a54527,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, KeyboardSettings>(
            (),
            0x357f6213b3a54527,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/KeyboardWatch.
pub struct KeyboardWatchRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for KeyboardWatchRequestStream {
    type Protocol = KeyboardWatchMarker;
    type ControlHandle = KeyboardWatchControlHandle;

    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 {
        KeyboardWatchControlHandle { 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 KeyboardWatchRequestStream {
    type Item = Result<KeyboardWatchRequest, 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 KeyboardWatchRequestStream 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 {
                    0x357f6213b3a54527 => {
                        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 =
                            KeyboardWatchControlHandle { inner: this.inner.clone() };
                        Ok(KeyboardWatchRequest::Watch {
                            responder: KeyboardWatchWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <KeyboardWatchMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The read-only API for monitoring the changes to the keyboard settings.
#[derive(Debug)]
pub enum KeyboardWatchRequest {
    /// The Watch protocol is the same as in the other `fuchsia.settings.*` protocols.
    ///
    /// Returns immediately on first call; on subsequent calls it blocks until the settings
    /// change, and then returns following the "hanging get" pattern.
    Watch { responder: KeyboardWatchWatchResponder },
}

impl KeyboardWatchRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(KeyboardWatchWatchResponder)> {
        if let KeyboardWatchRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut settings: &KeyboardSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<KeyboardWatchWatchResponse>(
            (settings,),
            self.tx_id,
            0x357f6213b3a54527,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for LightMarker {
    type Proxy = LightProxy;
    type RequestStream = LightRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LightSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Light";
}
impl fidl::endpoints::DiscoverableProtocolMarker for LightMarker {}
pub type LightSetLightGroupValuesResult = Result<(), LightError>;

pub trait LightProxyInterface: Send + Sync {
    type WatchLightGroupsResponseFut: std::future::Future<Output = Result<Vec<LightGroup>, fidl::Error>>
        + Send;
    fn r#watch_light_groups(&self) -> Self::WatchLightGroupsResponseFut;
    type WatchLightGroupResponseFut: std::future::Future<Output = Result<LightGroup, fidl::Error>>
        + Send;
    fn r#watch_light_group(&self, name: &str) -> Self::WatchLightGroupResponseFut;
    type SetLightGroupValuesResponseFut: std::future::Future<Output = Result<LightSetLightGroupValuesResult, fidl::Error>>
        + Send;
    fn r#set_light_group_values(
        &self,
        name: &str,
        state: &[LightState],
    ) -> Self::SetLightGroupValuesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LightSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LightSynchronousProxy {
    type Proxy = LightProxy;
    type Protocol = LightMarker;

    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 LightSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <LightMarker 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<LightEvent, fidl::Error> {
        LightEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Fetches information on the controllable light groups on the device.
    /// Returns immediately on first call; subsequent calls return when the
    /// value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch_light_groups(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<LightGroup>, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, LightWatchLightGroupsResponse>(
                (),
                0x3f506de229db5930,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.groups)
    }

    /// Fetches information on an individual light group on the device with the
    /// given name. Returns immediately on first call; subsequent calls return
    /// when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed. If the failure is due to an invalid light group name,
    /// the channel will be closed with a NOT_FOUND epitaph.
    pub fn r#watch_light_group(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LightGroup, fidl::Error> {
        let _response =
            self.client.send_query::<LightWatchLightGroupRequest, LightWatchLightGroupResponse>(
                (name,),
                0x3ef0331c388d56a3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.group)
    }

    /// Sets the values for the lights in the group with the given name.
    ///
    /// If the provided value does not match the light group's type, this
    /// call will fail.
    ///
    /// The requested changes may not take immediate effect if
    /// the light is forced to a certain state by the device's hardware. This
    /// call will still succeed, but the light's value may not change.
    pub fn r#set_light_group_values(
        &self,
        mut name: &str,
        mut state: &[LightState],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LightSetLightGroupValuesResult, fidl::Error> {
        let _response = self.client.send_query::<
            LightSetLightGroupValuesRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, LightError>,
        >(
            (name, state,),
            0x15d9b62431fdf8d5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LightProxy {
    type Protocol = LightMarker;

    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 LightProxy {
    /// Create a new Proxy for fuchsia.settings/Light.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LightMarker 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) -> LightEventStream {
        LightEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Fetches information on the controllable light groups on the device.
    /// Returns immediately on first call; subsequent calls return when the
    /// value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch_light_groups(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<LightGroup>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LightProxyInterface::r#watch_light_groups(self)
    }

    /// Fetches information on an individual light group on the device with the
    /// given name. Returns immediately on first call; subsequent calls return
    /// when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed. If the failure is due to an invalid light group name,
    /// the channel will be closed with a NOT_FOUND epitaph.
    pub fn r#watch_light_group(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<LightGroup, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        LightProxyInterface::r#watch_light_group(self, name)
    }

    /// Sets the values for the lights in the group with the given name.
    ///
    /// If the provided value does not match the light group's type, this
    /// call will fail.
    ///
    /// The requested changes may not take immediate effect if
    /// the light is forced to a certain state by the device's hardware. This
    /// call will still succeed, but the light's value may not change.
    pub fn r#set_light_group_values(
        &self,
        mut name: &str,
        mut state: &[LightState],
    ) -> fidl::client::QueryResponseFut<
        LightSetLightGroupValuesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LightProxyInterface::r#set_light_group_values(self, name, state)
    }
}

impl LightProxyInterface for LightProxy {
    type WatchLightGroupsResponseFut = fidl::client::QueryResponseFut<
        Vec<LightGroup>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_light_groups(&self) -> Self::WatchLightGroupsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<LightGroup>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LightWatchLightGroupsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3f506de229db5930,
            >(_buf?)?;
            Ok(_response.groups)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<LightGroup>>(
            (),
            0x3f506de229db5930,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchLightGroupResponseFut =
        fidl::client::QueryResponseFut<LightGroup, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_light_group(&self, mut name: &str) -> Self::WatchLightGroupResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LightGroup, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LightWatchLightGroupResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ef0331c388d56a3,
            >(_buf?)?;
            Ok(_response.group)
        }
        self.client.send_query_and_decode::<LightWatchLightGroupRequest, LightGroup>(
            (name,),
            0x3ef0331c388d56a3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetLightGroupValuesResponseFut = fidl::client::QueryResponseFut<
        LightSetLightGroupValuesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_light_group_values(
        &self,
        mut name: &str,
        mut state: &[LightState],
    ) -> Self::SetLightGroupValuesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LightSetLightGroupValuesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, LightError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x15d9b62431fdf8d5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LightSetLightGroupValuesRequest,
            LightSetLightGroupValuesResult,
        >(
            (name, state,),
            0x15d9b62431fdf8d5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Light.
pub struct LightRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for LightRequestStream {
    type Protocol = LightMarker;
    type ControlHandle = LightControlHandle;

    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 {
        LightControlHandle { 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 LightRequestStream {
    type Item = Result<LightRequest, 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 LightRequestStream 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 {
                    0x3f506de229db5930 => {
                        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 = LightControlHandle { inner: this.inner.clone() };
                        Ok(LightRequest::WatchLightGroups {
                            responder: LightWatchLightGroupsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ef0331c388d56a3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LightWatchLightGroupRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LightWatchLightGroupRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LightControlHandle { inner: this.inner.clone() };
                        Ok(LightRequest::WatchLightGroup {
                            name: req.name,

                            responder: LightWatchLightGroupResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x15d9b62431fdf8d5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LightSetLightGroupValuesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LightSetLightGroupValuesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LightControlHandle { inner: this.inner.clone() };
                        Ok(LightRequest::SetLightGroupValues {
                            name: req.name,
                            state: req.state,

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

#[derive(Debug)]
pub enum LightRequest {
    /// Fetches information on the controllable light groups on the device.
    /// Returns immediately on first call; subsequent calls return when the
    /// value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    WatchLightGroups { responder: LightWatchLightGroupsResponder },
    /// Fetches information on an individual light group on the device with the
    /// given name. Returns immediately on first call; subsequent calls return
    /// when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed. If the failure is due to an invalid light group name,
    /// the channel will be closed with a NOT_FOUND epitaph.
    WatchLightGroup { name: String, responder: LightWatchLightGroupResponder },
    /// Sets the values for the lights in the group with the given name.
    ///
    /// If the provided value does not match the light group's type, this
    /// call will fail.
    ///
    /// The requested changes may not take immediate effect if
    /// the light is forced to a certain state by the device's hardware. This
    /// call will still succeed, but the light's value may not change.
    SetLightGroupValues {
        name: String,
        state: Vec<LightState>,
        responder: LightSetLightGroupValuesResponder,
    },
}

impl LightRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_light_groups(self) -> Option<(LightWatchLightGroupsResponder)> {
        if let LightRequest::WatchLightGroups { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_light_group(self) -> Option<(String, LightWatchLightGroupResponder)> {
        if let LightRequest::WatchLightGroup { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_light_group_values(
        self,
    ) -> Option<(String, Vec<LightState>, LightSetLightGroupValuesResponder)> {
        if let LightRequest::SetLightGroupValues { name, state, responder } = self {
            Some((name, state, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LightRequest::WatchLightGroups { .. } => "watch_light_groups",
            LightRequest::WatchLightGroup { .. } => "watch_light_group",
            LightRequest::SetLightGroupValues { .. } => "set_light_group_values",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut groups: &[LightGroup]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<LightWatchLightGroupsResponse>(
            (groups,),
            self.tx_id,
            0x3f506de229db5930,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut group: &LightGroup) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<LightWatchLightGroupResponse>(
            (group,),
            self.tx_id,
            0x3ef0331c388d56a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for NightModeMarker {
    type Proxy = NightModeProxy;
    type RequestStream = NightModeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NightModeSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.NightMode";
}
impl fidl::endpoints::DiscoverableProtocolMarker for NightModeMarker {}
pub type NightModeSetResult = Result<(), Error>;

pub trait NightModeProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<NightModeSettings, fidl::Error>>
        + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<NightModeSetResult, fidl::Error>>
        + Send;
    fn r#set(&self, settings: &NightModeSettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NightModeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NightModeSynchronousProxy {
    type Proxy = NightModeProxy;
    type Protocol = NightModeMarker;

    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 NightModeSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <NightModeMarker 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<NightModeEvent, fidl::Error> {
        NightModeEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [`NightModeSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NightModeSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NightModeWatchResponse>(
                (),
                0x7e1509bf8c7582f6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets [`NightModeSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &NightModeSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NightModeSetResult, fidl::Error> {
        let _response = self.client.send_query::<NightModeSetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings,),
            0x28c3d78ab05b55cd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for NightModeProxy {
    type Protocol = NightModeMarker;

    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 NightModeProxy {
    /// Create a new Proxy for fuchsia.settings/NightMode.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NightModeMarker 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) -> NightModeEventStream {
        NightModeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [`NightModeSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NightModeSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NightModeProxyInterface::r#watch(self)
    }

    /// Sets [`NightModeSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &NightModeSettings,
    ) -> fidl::client::QueryResponseFut<
        NightModeSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NightModeProxyInterface::r#set(self, settings)
    }
}

impl NightModeProxyInterface for NightModeProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        NightModeSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NightModeSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NightModeWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e1509bf8c7582f6,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NightModeSettings>(
            (),
            0x7e1509bf8c7582f6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        NightModeSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &NightModeSettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NightModeSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x28c3d78ab05b55cd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NightModeSetRequest, NightModeSetResult>(
            (settings,),
            0x28c3d78ab05b55cd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/NightMode.
pub struct NightModeRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NightModeRequestStream {
    type Protocol = NightModeMarker;
    type ControlHandle = NightModeControlHandle;

    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 {
        NightModeControlHandle { 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 NightModeRequestStream {
    type Item = Result<NightModeRequest, 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 NightModeRequestStream 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 {
                    0x7e1509bf8c7582f6 => {
                        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 = NightModeControlHandle { inner: this.inner.clone() };
                        Ok(NightModeRequest::Watch {
                            responder: NightModeWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x28c3d78ab05b55cd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NightModeSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NightModeSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NightModeControlHandle { inner: this.inner.clone() };
                        Ok(NightModeRequest::Set {
                            settings: req.settings,

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

/// Modify or watch Night Mode setting. Night mode puts the device in a
/// restricted mode which can be overrided if the user prefers. During night
/// mode, the following settings apply as per night mode parameters:
/// 1. DoNotDisturb is enabled/not.
/// 2. System volume is set to an override maximum.
/// 3. LED Brightness is set to an overridable maximum.
/// 4. Sleep mode is enabled/not.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum NightModeRequest {
    /// Gets the current [`NightModeSettings`]. Returns immediately on first
    /// call; subsequent calls return when the values change.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: NightModeWatchResponder },
    /// Sets [`NightModeSettings`] settings. Any field not explicitly set in
    /// the table performs a no-op, and will not make any changes.
    Set { settings: NightModeSettings, responder: NightModeSetResponder },
}

impl NightModeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(NightModeWatchResponder)> {
        if let NightModeRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(NightModeSettings, NightModeSetResponder)> {
        if let NightModeRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NightModeRequest::Watch { .. } => "watch",
            NightModeRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &NightModeSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NightModeWatchResponse>(
            (settings,),
            self.tx_id,
            0x7e1509bf8c7582f6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for PrivacyMarker {
    type Proxy = PrivacyProxy;
    type RequestStream = PrivacyRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PrivacySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Privacy";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PrivacyMarker {}
pub type PrivacySetResult = Result<(), Error>;

pub trait PrivacyProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<PrivacySettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<PrivacySetResult, fidl::Error>> + Send;
    fn r#set(&self, settings: &PrivacySettings) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PrivacySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PrivacySynchronousProxy {
    type Proxy = PrivacyProxy;
    type Protocol = PrivacyMarker;

    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 PrivacySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PrivacyMarker 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<PrivacyEvent, fidl::Error> {
        PrivacyEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Notifies of a change in privacy settings.
    ///
    /// On a given connection, the server will return immediately if this is the first call made,
    /// or if the `settings` value has changed since a previous call. Otherwise, the server will
    /// wait on a value change before returning the new value. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    pub fn r#watch(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PrivacySettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, PrivacyWatchResponse>(
                (),
                0x1cb0c420ed81f47c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Sets the privacy settings.
    ///
    /// Any field not explicitly set in `settings` performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &PrivacySettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PrivacySetResult, fidl::Error> {
        let _response = self.client.send_query::<PrivacySetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings,),
            0xe2f4a1c85885537,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PrivacyProxy {
    type Protocol = PrivacyMarker;

    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 PrivacyProxy {
    /// Create a new Proxy for fuchsia.settings/Privacy.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PrivacyMarker 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) -> PrivacyEventStream {
        PrivacyEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Notifies of a change in privacy settings.
    ///
    /// On a given connection, the server will return immediately if this is the first call made,
    /// or if the `settings` value has changed since a previous call. Otherwise, the server will
    /// wait on a value change before returning the new value. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PrivacySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PrivacyProxyInterface::r#watch(self)
    }

    /// Sets the privacy settings.
    ///
    /// Any field not explicitly set in `settings` performs a no-op, and will not make any changes.
    pub fn r#set(
        &self,
        mut settings: &PrivacySettings,
    ) -> fidl::client::QueryResponseFut<
        PrivacySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PrivacyProxyInterface::r#set(self, settings)
    }
}

impl PrivacyProxyInterface for PrivacyProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        PrivacySettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PrivacySettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PrivacyWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cb0c420ed81f47c,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PrivacySettings>(
            (),
            0x1cb0c420ed81f47c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        PrivacySetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &PrivacySettings) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PrivacySetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xe2f4a1c85885537,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PrivacySetRequest, PrivacySetResult>(
            (settings,),
            0xe2f4a1c85885537,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Privacy.
pub struct PrivacyRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PrivacyRequestStream {
    type Protocol = PrivacyMarker;
    type ControlHandle = PrivacyControlHandle;

    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 {
        PrivacyControlHandle { 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 PrivacyRequestStream {
    type Item = Result<PrivacyRequest, 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 PrivacyRequestStream 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 {
                    0x1cb0c420ed81f47c => {
                        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 = PrivacyControlHandle { inner: this.inner.clone() };
                        Ok(PrivacyRequest::Watch {
                            responder: PrivacyWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xe2f4a1c85885537 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PrivacySetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrivacySetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrivacyControlHandle { inner: this.inner.clone() };
                        Ok(PrivacyRequest::Set {
                            settings: req.settings,

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

/// Settings related to privacy.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum PrivacyRequest {
    /// Notifies of a change in privacy settings.
    ///
    /// On a given connection, the server will return immediately if this is the first call made,
    /// or if the `settings` value has changed since a previous call. Otherwise, the server will
    /// wait on a value change before returning the new value. This follows the hanging get pattern.
    ///
    /// If this call fails, it is considered a fatal error and the channel will be closed.
    Watch { responder: PrivacyWatchResponder },
    /// Sets the privacy settings.
    ///
    /// Any field not explicitly set in `settings` performs a no-op, and will not make any changes.
    Set { settings: PrivacySettings, responder: PrivacySetResponder },
}

impl PrivacyRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(PrivacyWatchResponder)> {
        if let PrivacyRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(PrivacySettings, PrivacySetResponder)> {
        if let PrivacyRequest::Set { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PrivacyRequest::Watch { .. } => "watch",
            PrivacyRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &PrivacySettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PrivacyWatchResponse>(
            (settings,),
            self.tx_id,
            0x1cb0c420ed81f47c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for SetupMarker {
    type Proxy = SetupProxy;
    type RequestStream = SetupRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SetupSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.settings.Setup";
}
impl fidl::endpoints::DiscoverableProtocolMarker for SetupMarker {}
pub type SetupSetResult = Result<(), Error>;

pub trait SetupProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<SetupSettings, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetResponseFut: std::future::Future<Output = Result<SetupSetResult, fidl::Error>> + Send;
    fn r#set(&self, settings: &SetupSettings, reboot_device: bool) -> Self::SetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SetupSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SetupSynchronousProxy {
    type Proxy = SetupProxy;
    type Protocol = SetupMarker;

    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 SetupSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SetupMarker 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<SetupEvent, fidl::Error> {
        SetupEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Gets the current [SetupSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<SetupSettings, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, SetupWatchResponse>(
                (),
                0xd3893c0e63c0a6e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.settings)
    }

    /// Changes the settings specified in [SetupSettings]. Any field not set in
    /// the table will not perform any system operation. An error will be
    /// returned if the provided settings is an invalid change (for example, if
    /// it is empty).
    pub fn r#set(
        &self,
        mut settings: &SetupSettings,
        mut reboot_device: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SetupSetResult, fidl::Error> {
        let _response = self.client.send_query::<SetupSetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >>(
            (settings, reboot_device),
            0x66a20be769388128,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SetupProxy {
    type Protocol = SetupMarker;

    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 SetupProxy {
    /// Create a new Proxy for fuchsia.settings/Setup.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SetupMarker 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) -> SetupEventStream {
        SetupEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current [SetupSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<SetupSettings, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SetupProxyInterface::r#watch(self)
    }

    /// Changes the settings specified in [SetupSettings]. Any field not set in
    /// the table will not perform any system operation. An error will be
    /// returned if the provided settings is an invalid change (for example, if
    /// it is empty).
    pub fn r#set(
        &self,
        mut settings: &SetupSettings,
        mut reboot_device: bool,
    ) -> fidl::client::QueryResponseFut<SetupSetResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SetupProxyInterface::r#set(self, settings, reboot_device)
    }
}

impl SetupProxyInterface for SetupProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        SetupSettings,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SetupSettings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SetupWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xd3893c0e63c0a6e,
            >(_buf?)?;
            Ok(_response.settings)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SetupSettings>(
            (),
            0xd3893c0e63c0a6e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetResponseFut = fidl::client::QueryResponseFut<
        SetupSetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set(&self, mut settings: &SetupSettings, mut reboot_device: bool) -> Self::SetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SetupSetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x66a20be769388128,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SetupSetRequest, SetupSetResult>(
            (settings, reboot_device),
            0x66a20be769388128,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.settings/Setup.
pub struct SetupRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SetupRequestStream {
    type Protocol = SetupMarker;
    type ControlHandle = SetupControlHandle;

    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 {
        SetupControlHandle { 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 SetupRequestStream {
    type Item = Result<SetupRequest, 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 SetupRequestStream 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 {
                    0xd3893c0e63c0a6e => {
                        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 = SetupControlHandle { inner: this.inner.clone() };
                        Ok(SetupRequest::Watch {
                            responder: SetupWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66a20be769388128 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SetupSetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SetupSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SetupControlHandle { inner: this.inner.clone() };
                        Ok(SetupRequest::Set {
                            settings: req.settings,
                            reboot_device: req.reboot_device,

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

/// Settings that influence the device's setup behavior.
///
/// Supported SettingsEpitaph enums:
/// REQUEST_NOT_SUPPORTED, INTERNAL_SERVICE_ERROR, PERSISTENT_STORAGE_ERROR
#[derive(Debug)]
pub enum SetupRequest {
    /// Gets the current [SetupSettings]. Returns immediately on first call;
    /// subsequent calls return when the value changes.
    ///
    /// If this call fails, it is considered a fatal error and the channel
    /// will be closed.
    Watch { responder: SetupWatchResponder },
    /// Changes the settings specified in [SetupSettings]. Any field not set in
    /// the table will not perform any system operation. An error will be
    /// returned if the provided settings is an invalid change (for example, if
    /// it is empty).
    Set { settings: SetupSettings, reboot_device: bool, responder: SetupSetResponder },
}

impl SetupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(SetupWatchResponder)> {
        if let SetupRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(SetupSettings, bool, SetupSetResponder)> {
        if let SetupRequest::Set { settings, reboot_device, responder } = self {
            Some((settings, reboot_device, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SetupRequest::Watch { .. } => "watch",
            SetupRequest::Set { .. } => "set",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut settings: &SetupSettings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SetupWatchResponse>(
            (settings,),
            self.tx_id,
            0xd3893c0e63c0a6e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

mod internal {
    use super::*;
}