fidl_fuchsia_virtualization_hardware/

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

/// Contains the basic information required to start execution of a device.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StartInfo {
    /// The trap associated with a device. It is up to the device to set this
    /// trap during device setup.
    pub trap: Trap,
    /// The guest associated with a device. This handle should be used to setup
    /// device traps, and then be released before device operation begins.
    pub guest: Option<fidl::Guest>,
    /// The event associated with a device interrupt. This is how the device will
    /// notify the guest of events it should process.
    ///
    /// The meaning of the different signals that can be raised on the event are
    /// documented by the EVENT_* constants above.
    pub event: fidl::Event,
    /// The VMO used to represent guest physical memory.
    pub vmo: fidl::Vmo,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioBalloonStartRequest {
    pub start_info: StartInfo,
}

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

#[derive(Debug, PartialEq)]
pub struct VirtioBlockStartRequest {
    pub start_info: StartInfo,
    pub spec: fidl_fuchsia_virtualization::BlockSpec,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioConsoleStartRequest {
    pub start_info: StartInfo,
    pub socket: fidl::Socket,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioGpuStartRequest {
    pub start_info: StartInfo,
    pub keyboard_listener:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>>,
    pub mouse_source:
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioInputStartRequest {
    pub start_info: StartInfo,
    pub input_type: InputType,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioMemStartRequest {
    pub start_info: StartInfo,
    pub region_addr: u64,
    pub plugged_block_size: u64,
    pub region_size: u64,
}

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

#[derive(Debug, PartialEq)]
pub struct VirtioNetStartRequest {
    pub start_info: StartInfo,
    pub mac_address: fidl_fuchsia_net::MacAddress,
    pub enable_bridge: bool,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioRngStartRequest {
    pub start_info: StartInfo,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VirtioSoundStartRequest {
    pub start_info: StartInfo,
    pub enable_input: bool,
    pub enable_verbose_logging: bool,
}

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

#[derive(Debug, PartialEq)]
pub struct VirtioVsockStartRequest {
    pub start_info: StartInfo,
    pub guest_cid: u32,
    pub listeners: Vec<fidl_fuchsia_virtualization::Listener>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum InputType {
    Keyboard(fidl::endpoints::ServerEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>),
    Mouse(fidl::endpoints::ClientEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>),
}

impl InputType {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Keyboard(_) => 1,
            Self::Mouse(_) => 2,
        }
    }
}

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

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

impl fidl::endpoints::ProtocolMarker for VirtioBalloonMarker {
    type Proxy = VirtioBalloonProxy;
    type RequestStream = VirtioBalloonRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioBalloonSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioBalloon";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioBalloonMarker {}

pub trait VirtioBalloonProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(&self, start_info: StartInfo) -> Self::StartResponseFut;
    type GetMemStatsResponseFut: std::future::Future<
            Output = Result<(i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>), fidl::Error>,
        > + Send;
    fn r#get_mem_stats(&self) -> Self::GetMemStatsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioBalloonSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioBalloonSynchronousProxy {
    type Proxy = VirtioBalloonProxy;
    type Protocol = VirtioBalloonMarker;

    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 VirtioBalloonSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioBalloonMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioBalloonMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the balloon device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioBalloonStartRequest,
            fidl::encoding::EmptyPayload,
            VirtioBalloonMarker,
        >(
            (&mut start_info,),
            0x26645282fddf6f46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Get memory statistics from the balloon device.
    pub fn r#get_mem_stats(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            VirtioBalloonGetMemStatsResponse,
            VirtioBalloonMarker,
        >(
            (),
            0x6641f4c296607e24,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.mem_stats))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioBalloonProxy {
    type Protocol = VirtioBalloonMarker;

    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 VirtioBalloonProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioBalloon.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioBalloonMarker 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) -> VirtioBalloonEventStream {
        VirtioBalloonEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioBalloonProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioBalloonProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioBalloonProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the balloon device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioBalloonProxyInterface::r#start(self, start_info)
    }

    /// Get memory statistics from the balloon device.
    pub fn r#get_mem_stats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VirtioBalloonProxyInterface::r#get_mem_stats(self)
    }
}

impl VirtioBalloonProxyInterface for VirtioBalloonProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(&self, mut start_info: StartInfo) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x26645282fddf6f46,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioBalloonStartRequest, ()>(
            (&mut start_info,),
            0x26645282fddf6f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMemStatsResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mem_stats(&self) -> Self::GetMemStatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VirtioBalloonGetMemStatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6641f4c296607e24,
            >(_buf?)?;
            Ok((_response.status, _response.mem_stats))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Vec<fidl_fuchsia_virtualization::MemStat>>),
        >(
            (),
            0x6641f4c296607e24,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioBalloon.
pub struct VirtioBalloonRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioBalloonRequestStream {
    type Protocol = VirtioBalloonMarker;
    type ControlHandle = VirtioBalloonControlHandle;

    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 {
        VirtioBalloonControlHandle { 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 VirtioBalloonRequestStream {
    type Item = Result<VirtioBalloonRequest, 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 VirtioBalloonRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioBalloonControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBalloonRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioBalloonConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioBalloonControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBalloonRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioBalloonControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBalloonRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioBalloonReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x26645282fddf6f46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioBalloonStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioBalloonStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioBalloonControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBalloonRequest::Start {
                            start_info: req.start_info,

                            responder: VirtioBalloonStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6641f4c296607e24 => {
                        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 =
                            VirtioBalloonControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBalloonRequest::GetMemStats {
                            responder: VirtioBalloonGetMemStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <VirtioBalloonMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum VirtioBalloonRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioBalloonConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioBalloonControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioBalloonReadyResponder },
    /// Start the balloon device.
    Start { start_info: StartInfo, responder: VirtioBalloonStartResponder },
    /// Get memory statistics from the balloon device.
    GetMemStats { responder: VirtioBalloonGetMemStatsResponder },
}

impl VirtioBalloonRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioBalloonConfigureQueueResponder)> {
        if let VirtioBalloonRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioBalloonControlHandle)> {
        if let VirtioBalloonRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioBalloonReadyResponder)> {
        if let VirtioBalloonRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, VirtioBalloonStartResponder)> {
        if let VirtioBalloonRequest::Start { start_info, responder } = self {
            Some((start_info, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mem_stats(self) -> Option<(VirtioBalloonGetMemStatsResponder)> {
        if let VirtioBalloonRequest::GetMemStats { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioBalloonRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioBalloonRequest::NotifyQueue { .. } => "notify_queue",
            VirtioBalloonRequest::Ready { .. } => "ready",
            VirtioBalloonRequest::Start { .. } => "start",
            VirtioBalloonRequest::GetMemStats { .. } => "get_mem_stats",
        }
    }
}

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

impl VirtioBalloonControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioBalloonControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut status: i32,
        mut mem_stats: Option<&[fidl_fuchsia_virtualization::MemStat]>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<VirtioBalloonGetMemStatsResponse>(
            (status, mem_stats),
            self.tx_id,
            0x6641f4c296607e24,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VirtioBlockMarker {
    type Proxy = VirtioBlockProxy;
    type RequestStream = VirtioBlockRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioBlockSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioBlock";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioBlockMarker {}

pub trait VirtioBlockProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(u64, u32), fidl::Error>> + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        spec: fidl_fuchsia_virtualization::BlockSpec,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioBlockSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioBlockSynchronousProxy {
    type Proxy = VirtioBlockProxy;
    type Protocol = VirtioBlockMarker;

    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 VirtioBlockSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioBlockMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioBlockMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the block device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut spec: fidl_fuchsia_virtualization::BlockSpec,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u64, u32), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioBlockStartRequest, VirtioBlockStartResponse, VirtioBlockMarker>(
                (&mut start_info, &mut spec),
                0x5ef6a4b9ce9adcb2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.capacity, _response.block_size))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioBlockProxy {
    type Protocol = VirtioBlockMarker;

    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 VirtioBlockProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioBlock.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioBlockMarker 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) -> VirtioBlockEventStream {
        VirtioBlockEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioBlockProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioBlockProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioBlockProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the block device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut spec: fidl_fuchsia_virtualization::BlockSpec,
    ) -> fidl::client::QueryResponseFut<(u64, u32), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        VirtioBlockProxyInterface::r#start(self, start_info, spec)
    }
}

impl VirtioBlockProxyInterface for VirtioBlockProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(u64, u32), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut spec: fidl_fuchsia_virtualization::BlockSpec,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u64, u32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VirtioBlockStartResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ef6a4b9ce9adcb2,
            >(_buf?)?;
            Ok((_response.capacity, _response.block_size))
        }
        self.client.send_query_and_decode::<VirtioBlockStartRequest, (u64, u32)>(
            (&mut start_info, &mut spec),
            0x5ef6a4b9ce9adcb2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioBlock.
pub struct VirtioBlockRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioBlockRequestStream {
    type Protocol = VirtioBlockMarker;
    type ControlHandle = VirtioBlockControlHandle;

    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 {
        VirtioBlockControlHandle { 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 VirtioBlockRequestStream {
    type Item = Result<VirtioBlockRequest, 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 VirtioBlockRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioBlockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBlockRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioBlockConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioBlockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBlockRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioBlockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBlockRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioBlockReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ef6a4b9ce9adcb2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioBlockStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioBlockStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioBlockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioBlockRequest::Start {
                            start_info: req.start_info,
                            spec: req.spec,

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

#[derive(Debug)]
pub enum VirtioBlockRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioBlockConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioBlockControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioBlockReadyResponder },
    /// Start the block device.
    Start {
        start_info: StartInfo,
        spec: fidl_fuchsia_virtualization::BlockSpec,
        responder: VirtioBlockStartResponder,
    },
}

impl VirtioBlockRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioBlockConfigureQueueResponder)> {
        if let VirtioBlockRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioBlockControlHandle)> {
        if let VirtioBlockRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioBlockReadyResponder)> {
        if let VirtioBlockRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(StartInfo, fidl_fuchsia_virtualization::BlockSpec, VirtioBlockStartResponder)>
    {
        if let VirtioBlockRequest::Start { start_info, spec, responder } = self {
            Some((start_info, spec, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioBlockRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioBlockRequest::NotifyQueue { .. } => "notify_queue",
            VirtioBlockRequest::Ready { .. } => "ready",
            VirtioBlockRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioBlockControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioBlockControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut capacity: u64, mut block_size: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<VirtioBlockStartResponse>(
            (capacity, block_size),
            self.tx_id,
            0x5ef6a4b9ce9adcb2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VirtioConsoleMarker {
    type Proxy = VirtioConsoleProxy;
    type RequestStream = VirtioConsoleRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioConsoleSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioConsole";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioConsoleMarker {}

pub trait VirtioConsoleProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(&self, start_info: StartInfo, socket: fidl::Socket) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioConsoleSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioConsoleSynchronousProxy {
    type Proxy = VirtioConsoleProxy;
    type Protocol = VirtioConsoleMarker;

    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 VirtioConsoleSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioConsoleMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioConsoleMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the console device. This uses `socket` to handle input and output.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut socket: fidl::Socket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioConsoleStartRequest,
            fidl::encoding::EmptyPayload,
            VirtioConsoleMarker,
        >(
            (&mut start_info, socket,),
            0x10a6267f2ab7e24c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioConsoleProxy {
    type Protocol = VirtioConsoleMarker;

    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 VirtioConsoleProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioConsole.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioConsoleMarker 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) -> VirtioConsoleEventStream {
        VirtioConsoleEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioConsoleProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioConsoleProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioConsoleProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the console device. This uses `socket` to handle input and output.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut socket: fidl::Socket,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioConsoleProxyInterface::r#start(self, start_info, socket)
    }
}

impl VirtioConsoleProxyInterface for VirtioConsoleProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut socket: fidl::Socket,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x10a6267f2ab7e24c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioConsoleStartRequest, ()>(
            (&mut start_info, socket),
            0x10a6267f2ab7e24c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioConsole.
pub struct VirtioConsoleRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioConsoleRequestStream {
    type Protocol = VirtioConsoleMarker;
    type ControlHandle = VirtioConsoleControlHandle;

    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 {
        VirtioConsoleControlHandle { 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 VirtioConsoleRequestStream {
    type Item = Result<VirtioConsoleRequest, 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 VirtioConsoleRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioConsoleControlHandle { inner: this.inner.clone() };
                        Ok(VirtioConsoleRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioConsoleConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioConsoleControlHandle { inner: this.inner.clone() };
                        Ok(VirtioConsoleRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioConsoleControlHandle { inner: this.inner.clone() };
                        Ok(VirtioConsoleRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioConsoleReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x10a6267f2ab7e24c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioConsoleStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioConsoleStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioConsoleControlHandle { inner: this.inner.clone() };
                        Ok(VirtioConsoleRequest::Start {
                            start_info: req.start_info,
                            socket: req.socket,

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

#[derive(Debug)]
pub enum VirtioConsoleRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioConsoleConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioConsoleControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioConsoleReadyResponder },
    /// Start the console device. This uses `socket` to handle input and output.
    Start { start_info: StartInfo, socket: fidl::Socket, responder: VirtioConsoleStartResponder },
}

impl VirtioConsoleRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioConsoleConfigureQueueResponder)> {
        if let VirtioConsoleRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioConsoleControlHandle)> {
        if let VirtioConsoleRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioConsoleReadyResponder)> {
        if let VirtioConsoleRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, fidl::Socket, VirtioConsoleStartResponder)> {
        if let VirtioConsoleRequest::Start { start_info, socket, responder } = self {
            Some((start_info, socket, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioConsoleRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioConsoleRequest::NotifyQueue { .. } => "notify_queue",
            VirtioConsoleRequest::Ready { .. } => "ready",
            VirtioConsoleRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioConsoleControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioConsoleControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioDeviceMarker {
    type Proxy = VirtioDeviceProxy;
    type RequestStream = VirtioDeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioDeviceSynchronousProxy;

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

pub trait VirtioDeviceProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioDeviceSynchronousProxy {
    type Proxy = VirtioDeviceProxy;
    type Protocol = VirtioDeviceMarker;

    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 VirtioDeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioDeviceMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioDeviceMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioDeviceProxy {
    type Protocol = VirtioDeviceMarker;

    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 VirtioDeviceProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioDevice.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioDeviceMarker 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) -> VirtioDeviceEventStream {
        VirtioDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioDeviceProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioDeviceProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioDeviceProxyInterface::r#ready(self, negotiated_features)
    }
}

impl VirtioDeviceProxyInterface for VirtioDeviceProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioDevice.
pub struct VirtioDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioDeviceRequestStream {
    type Protocol = VirtioDeviceMarker;
    type ControlHandle = VirtioDeviceControlHandle;

    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 {
        VirtioDeviceControlHandle { 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 VirtioDeviceRequestStream {
    type Item = Result<VirtioDeviceRequest, 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 VirtioDeviceRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioDeviceControlHandle { inner: this.inner.clone() };
                        Ok(VirtioDeviceRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioDeviceConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioDeviceControlHandle { inner: this.inner.clone() };
                        Ok(VirtioDeviceRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtioDeviceControlHandle { inner: this.inner.clone() };
                        Ok(VirtioDeviceRequest::Ready {
                            negotiated_features: req.negotiated_features,

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

#[derive(Debug)]
pub enum VirtioDeviceRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioDeviceConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioDeviceControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioDeviceReadyResponder },
}

impl VirtioDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioDeviceConfigureQueueResponder)> {
        if let VirtioDeviceRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioDeviceControlHandle)> {
        if let VirtioDeviceRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioDeviceReadyResponder)> {
        if let VirtioDeviceRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioDeviceRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioDeviceRequest::NotifyQueue { .. } => "notify_queue",
            VirtioDeviceRequest::Ready { .. } => "ready",
        }
    }
}

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

impl VirtioDeviceControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioDeviceControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioGpuMarker {
    type Proxy = VirtioGpuProxy;
    type RequestStream = VirtioGpuRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioGpuSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioGpu";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioGpuMarker {}

pub trait VirtioGpuProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        keyboard_listener: Option<
            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
        >,
        mouse_source: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
        >,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioGpuSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioGpuSynchronousProxy {
    type Proxy = VirtioGpuProxy;
    type Protocol = VirtioGpuMarker;

    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 VirtioGpuSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioGpuMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioDeviceReadyRequest, fidl::encoding::EmptyPayload, VirtioGpuMarker>(
                (negotiated_features,),
                0x45707654f5d23c3f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Start the GPU device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut keyboard_listener: Option<
            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
        >,
        mut mouse_source: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
        >,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioGpuStartRequest, fidl::encoding::EmptyPayload, VirtioGpuMarker>(
                (&mut start_info, keyboard_listener, mouse_source),
                0x7e81ed410f770c14,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioGpuProxy {
    type Protocol = VirtioGpuMarker;

    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 VirtioGpuProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioGpu.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioGpuMarker 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) -> VirtioGpuEventStream {
        VirtioGpuEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioGpuProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioGpuProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioGpuProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the GPU device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut keyboard_listener: Option<
            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
        >,
        mut mouse_source: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
        >,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioGpuProxyInterface::r#start(self, start_info, keyboard_listener, mouse_source)
    }
}

impl VirtioGpuProxyInterface for VirtioGpuProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut keyboard_listener: Option<
            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
        >,
        mut mouse_source: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
        >,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e81ed410f770c14,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioGpuStartRequest, ()>(
            (&mut start_info, keyboard_listener, mouse_source),
            0x7e81ed410f770c14,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum VirtioGpuEvent {
    OnConfigChanged {},
}

impl VirtioGpuEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_config_changed(self) -> Option<()> {
        if let VirtioGpuEvent::OnConfigChanged {} = self { Some(()) } else { None }
    }

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioGpu.
pub struct VirtioGpuRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioGpuRequestStream {
    type Protocol = VirtioGpuMarker;
    type ControlHandle = VirtioGpuControlHandle;

    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 {
        VirtioGpuControlHandle { 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 VirtioGpuRequestStream {
    type Item = Result<VirtioGpuRequest, 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 VirtioGpuRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioGpuControlHandle { inner: this.inner.clone() };
                        Ok(VirtioGpuRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioGpuConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioGpuControlHandle { inner: this.inner.clone() };
                        Ok(VirtioGpuRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioGpuControlHandle { inner: this.inner.clone() };
                        Ok(VirtioGpuRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioGpuReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e81ed410f770c14 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioGpuStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioGpuStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioGpuControlHandle { inner: this.inner.clone() };
                        Ok(VirtioGpuRequest::Start {
                            start_info: req.start_info,
                            keyboard_listener: req.keyboard_listener,
                            mouse_source: req.mouse_source,

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

#[derive(Debug)]
pub enum VirtioGpuRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioGpuConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioGpuControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioGpuReadyResponder },
    /// Start the GPU device.
    Start {
        start_info: StartInfo,
        keyboard_listener:
            Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>>,
        mouse_source:
            Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>>,
        responder: VirtioGpuStartResponder,
    },
}

impl VirtioGpuRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioGpuConfigureQueueResponder)> {
        if let VirtioGpuRequest::ConfigureQueue { queue, size, desc, avail, used, responder } = self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioGpuControlHandle)> {
        if let VirtioGpuRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioGpuReadyResponder)> {
        if let VirtioGpuRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(
        StartInfo,
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>>,
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>>,
        VirtioGpuStartResponder,
    )> {
        if let VirtioGpuRequest::Start { start_info, keyboard_listener, mouse_source, responder } =
            self
        {
            Some((start_info, keyboard_listener, mouse_source, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioGpuRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioGpuRequest::NotifyQueue { .. } => "notify_queue",
            VirtioGpuRequest::Ready { .. } => "ready",
            VirtioGpuRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioGpuControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioGpuControlHandle {
    pub fn send_on_config_changed(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x1555f5b7c8444aa0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioInputMarker {
    type Proxy = VirtioInputProxy;
    type RequestStream = VirtioInputRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioInputSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioInput";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioInputMarker {}

pub trait VirtioInputProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(&self, start_info: StartInfo, input_type: InputType) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioInputSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioInputSynchronousProxy {
    type Proxy = VirtioInputProxy;
    type Protocol = VirtioInputMarker;

    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 VirtioInputSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioInputMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioInputMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the input device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut input_type: InputType,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioInputStartRequest, fidl::encoding::EmptyPayload, VirtioInputMarker>(
                (&mut start_info, &mut input_type),
                0x612743931f7f9249,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioInputProxy {
    type Protocol = VirtioInputMarker;

    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 VirtioInputProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioInput.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioInputMarker 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) -> VirtioInputEventStream {
        VirtioInputEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioInputProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioInputProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioInputProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the input device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut input_type: InputType,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioInputProxyInterface::r#start(self, start_info, input_type)
    }
}

impl VirtioInputProxyInterface for VirtioInputProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut input_type: InputType,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x612743931f7f9249,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioInputStartRequest, ()>(
            (&mut start_info, &mut input_type),
            0x612743931f7f9249,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioInput.
pub struct VirtioInputRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioInputRequestStream {
    type Protocol = VirtioInputMarker;
    type ControlHandle = VirtioInputControlHandle;

    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 {
        VirtioInputControlHandle { 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 VirtioInputRequestStream {
    type Item = Result<VirtioInputRequest, 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 VirtioInputRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioInputControlHandle { inner: this.inner.clone() };
                        Ok(VirtioInputRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioInputConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioInputControlHandle { inner: this.inner.clone() };
                        Ok(VirtioInputRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioInputControlHandle { inner: this.inner.clone() };
                        Ok(VirtioInputRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioInputReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x612743931f7f9249 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioInputStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioInputStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioInputControlHandle { inner: this.inner.clone() };
                        Ok(VirtioInputRequest::Start {
                            start_info: req.start_info,
                            input_type: req.input_type,

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

#[derive(Debug)]
pub enum VirtioInputRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioInputConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioInputControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioInputReadyResponder },
    /// Start the input device.
    Start { start_info: StartInfo, input_type: InputType, responder: VirtioInputStartResponder },
}

impl VirtioInputRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioInputConfigureQueueResponder)> {
        if let VirtioInputRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioInputControlHandle)> {
        if let VirtioInputRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioInputReadyResponder)> {
        if let VirtioInputRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, InputType, VirtioInputStartResponder)> {
        if let VirtioInputRequest::Start { start_info, input_type, responder } = self {
            Some((start_info, input_type, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioInputRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioInputRequest::NotifyQueue { .. } => "notify_queue",
            VirtioInputRequest::Ready { .. } => "ready",
            VirtioInputRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioInputControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioInputControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioMemMarker {
    type Proxy = VirtioMemProxy;
    type RequestStream = VirtioMemRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioMemSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioMem";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioMemMarker {}

pub trait VirtioMemProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        region_addr: u64,
        plugged_block_size: u64,
        region_size: u64,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioMemSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioMemSynchronousProxy {
    type Proxy = VirtioMemProxy;
    type Protocol = VirtioMemMarker;

    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 VirtioMemSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioMemMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioDeviceReadyRequest, fidl::encoding::EmptyPayload, VirtioMemMarker>(
                (negotiated_features,),
                0x45707654f5d23c3f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Start the mem device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut region_addr: u64,
        mut plugged_block_size: u64,
        mut region_size: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioMemStartRequest, fidl::encoding::EmptyPayload, VirtioMemMarker>(
                (&mut start_info, region_addr, plugged_block_size, region_size),
                0x66dd64f17fb5223c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioMemProxy {
    type Protocol = VirtioMemMarker;

    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 VirtioMemProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioMem.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioMemMarker 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) -> VirtioMemEventStream {
        VirtioMemEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioMemProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioMemProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioMemProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the mem device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut region_addr: u64,
        mut plugged_block_size: u64,
        mut region_size: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioMemProxyInterface::r#start(
            self,
            start_info,
            region_addr,
            plugged_block_size,
            region_size,
        )
    }
}

impl VirtioMemProxyInterface for VirtioMemProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut region_addr: u64,
        mut plugged_block_size: u64,
        mut region_size: u64,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x66dd64f17fb5223c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioMemStartRequest, ()>(
            (&mut start_info, region_addr, plugged_block_size, region_size),
            0x66dd64f17fb5223c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum VirtioMemEvent {
    OnConfigChanged { plugged_size: u64 },
}

impl VirtioMemEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_config_changed(self) -> Option<u64> {
        if let VirtioMemEvent::OnConfigChanged { plugged_size } = self {
            Some((plugged_size))
        } else {
            None
        }
    }

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioMem.
pub struct VirtioMemRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioMemRequestStream {
    type Protocol = VirtioMemMarker;
    type ControlHandle = VirtioMemControlHandle;

    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 {
        VirtioMemControlHandle { 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 VirtioMemRequestStream {
    type Item = Result<VirtioMemRequest, 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 VirtioMemRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioMemControlHandle { inner: this.inner.clone() };
                        Ok(VirtioMemRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioMemConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioMemControlHandle { inner: this.inner.clone() };
                        Ok(VirtioMemRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioMemControlHandle { inner: this.inner.clone() };
                        Ok(VirtioMemRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioMemReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66dd64f17fb5223c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioMemStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioMemStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioMemControlHandle { inner: this.inner.clone() };
                        Ok(VirtioMemRequest::Start {
                            start_info: req.start_info,
                            region_addr: req.region_addr,
                            plugged_block_size: req.plugged_block_size,
                            region_size: req.region_size,

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

#[derive(Debug)]
pub enum VirtioMemRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioMemConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioMemControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioMemReadyResponder },
    /// Start the mem device.
    Start {
        start_info: StartInfo,
        region_addr: u64,
        plugged_block_size: u64,
        region_size: u64,
        responder: VirtioMemStartResponder,
    },
}

impl VirtioMemRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioMemConfigureQueueResponder)> {
        if let VirtioMemRequest::ConfigureQueue { queue, size, desc, avail, used, responder } = self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioMemControlHandle)> {
        if let VirtioMemRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioMemReadyResponder)> {
        if let VirtioMemRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, u64, u64, u64, VirtioMemStartResponder)> {
        if let VirtioMemRequest::Start {
            start_info,
            region_addr,
            plugged_block_size,
            region_size,
            responder,
        } = self
        {
            Some((start_info, region_addr, plugged_block_size, region_size, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioMemRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioMemRequest::NotifyQueue { .. } => "notify_queue",
            VirtioMemRequest::Ready { .. } => "ready",
            VirtioMemRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioMemControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioMemControlHandle {
    pub fn send_on_config_changed(&self, mut plugged_size: u64) -> Result<(), fidl::Error> {
        self.inner.send::<VirtioMemOnConfigChangedRequest>(
            (plugged_size,),
            0,
            0x73b86d7cc80020b9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioNetMarker {
    type Proxy = VirtioNetProxy;
    type RequestStream = VirtioNetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioNetSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioNet";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioNetMarker {}
pub type VirtioNetStartResult = Result<(), i32>;

pub trait VirtioNetProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<VirtioNetStartResult, fidl::Error>>
        + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        mac_address: &fidl_fuchsia_net::MacAddress,
        enable_bridge: bool,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioNetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioNetSynchronousProxy {
    type Proxy = VirtioNetProxy;
    type Protocol = VirtioNetMarker;

    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 VirtioNetSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioNetMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioDeviceReadyRequest, fidl::encoding::EmptyPayload, VirtioNetMarker>(
                (negotiated_features,),
                0x45707654f5d23c3f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Start the net device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut mac_address: &fidl_fuchsia_net::MacAddress,
        mut enable_bridge: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VirtioNetStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            VirtioNetStartRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            VirtioNetMarker,
        >(
            (&mut start_info, mac_address, enable_bridge,),
            0x795c0b3a8461b3ed,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioNetProxy {
    type Protocol = VirtioNetMarker;

    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 VirtioNetProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioNet.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioNetMarker 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) -> VirtioNetEventStream {
        VirtioNetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioNetProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioNetProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioNetProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the net device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut mac_address: &fidl_fuchsia_net::MacAddress,
        mut enable_bridge: bool,
    ) -> fidl::client::QueryResponseFut<
        VirtioNetStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VirtioNetProxyInterface::r#start(self, start_info, mac_address, enable_bridge)
    }
}

impl VirtioNetProxyInterface for VirtioNetProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut = fidl::client::QueryResponseFut<
        VirtioNetStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut mac_address: &fidl_fuchsia_net::MacAddress,
        mut enable_bridge: bool,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VirtioNetStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x795c0b3a8461b3ed,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<VirtioNetStartRequest, VirtioNetStartResult>(
            (&mut start_info, mac_address, enable_bridge),
            0x795c0b3a8461b3ed,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioNet.
pub struct VirtioNetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioNetRequestStream {
    type Protocol = VirtioNetMarker;
    type ControlHandle = VirtioNetControlHandle;

    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 {
        VirtioNetControlHandle { 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 VirtioNetRequestStream {
    type Item = Result<VirtioNetRequest, 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 VirtioNetRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioNetControlHandle { inner: this.inner.clone() };
                        Ok(VirtioNetRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioNetConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioNetControlHandle { inner: this.inner.clone() };
                        Ok(VirtioNetRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioNetControlHandle { inner: this.inner.clone() };
                        Ok(VirtioNetRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioNetReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x795c0b3a8461b3ed => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioNetStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioNetStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioNetControlHandle { inner: this.inner.clone() };
                        Ok(VirtioNetRequest::Start {
                            start_info: req.start_info,
                            mac_address: req.mac_address,
                            enable_bridge: req.enable_bridge,

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

#[derive(Debug)]
pub enum VirtioNetRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioNetConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioNetControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioNetReadyResponder },
    /// Start the net device.
    Start {
        start_info: StartInfo,
        mac_address: fidl_fuchsia_net::MacAddress,
        enable_bridge: bool,
        responder: VirtioNetStartResponder,
    },
}

impl VirtioNetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioNetConfigureQueueResponder)> {
        if let VirtioNetRequest::ConfigureQueue { queue, size, desc, avail, used, responder } = self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioNetControlHandle)> {
        if let VirtioNetRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioNetReadyResponder)> {
        if let VirtioNetRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(StartInfo, fidl_fuchsia_net::MacAddress, bool, VirtioNetStartResponder)> {
        if let VirtioNetRequest::Start { start_info, mac_address, enable_bridge, responder } = self
        {
            Some((start_info, mac_address, enable_bridge, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioNetRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioNetRequest::NotifyQueue { .. } => "notify_queue",
            VirtioNetRequest::Ready { .. } => "ready",
            VirtioNetRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioNetControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioNetControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioRngMarker {
    type Proxy = VirtioRngProxy;
    type RequestStream = VirtioRngRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioRngSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioRng";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioRngMarker {}

pub trait VirtioRngProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#start(&self, start_info: StartInfo) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioRngSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioRngSynchronousProxy {
    type Proxy = VirtioRngProxy;
    type Protocol = VirtioRngMarker;

    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 VirtioRngSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioRngMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioDeviceReadyRequest, fidl::encoding::EmptyPayload, VirtioRngMarker>(
                (negotiated_features,),
                0x45707654f5d23c3f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Start the RNG device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioRngStartRequest, fidl::encoding::EmptyPayload, VirtioRngMarker>(
                (&mut start_info,),
                0x620b3ed254febc0f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioRngProxy {
    type Protocol = VirtioRngMarker;

    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 VirtioRngProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioRng.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioRngMarker 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) -> VirtioRngEventStream {
        VirtioRngEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioRngProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioRngProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioRngProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the RNG device.
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioRngProxyInterface::r#start(self, start_info)
    }
}

impl VirtioRngProxyInterface for VirtioRngProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(&self, mut start_info: StartInfo) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x620b3ed254febc0f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioRngStartRequest, ()>(
            (&mut start_info,),
            0x620b3ed254febc0f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioRng.
pub struct VirtioRngRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioRngRequestStream {
    type Protocol = VirtioRngMarker;
    type ControlHandle = VirtioRngControlHandle;

    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 {
        VirtioRngControlHandle { 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 VirtioRngRequestStream {
    type Item = Result<VirtioRngRequest, 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 VirtioRngRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioRngControlHandle { inner: this.inner.clone() };
                        Ok(VirtioRngRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioRngConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioRngControlHandle { inner: this.inner.clone() };
                        Ok(VirtioRngRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioRngControlHandle { inner: this.inner.clone() };
                        Ok(VirtioRngRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioRngReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x620b3ed254febc0f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioRngStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioRngStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioRngControlHandle { inner: this.inner.clone() };
                        Ok(VirtioRngRequest::Start {
                            start_info: req.start_info,

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

#[derive(Debug)]
pub enum VirtioRngRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioRngConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioRngControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioRngReadyResponder },
    /// Start the RNG device.
    Start { start_info: StartInfo, responder: VirtioRngStartResponder },
}

impl VirtioRngRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioRngConfigureQueueResponder)> {
        if let VirtioRngRequest::ConfigureQueue { queue, size, desc, avail, used, responder } = self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioRngControlHandle)> {
        if let VirtioRngRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioRngReadyResponder)> {
        if let VirtioRngRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, VirtioRngStartResponder)> {
        if let VirtioRngRequest::Start { start_info, responder } = self {
            Some((start_info, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioRngRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioRngRequest::NotifyQueue { .. } => "notify_queue",
            VirtioRngRequest::Ready { .. } => "ready",
            VirtioRngRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioRngControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioRngControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for VirtioSoundMarker {
    type Proxy = VirtioSoundProxy;
    type RequestStream = VirtioSoundRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioSoundSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioSound";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioSoundMarker {}

pub trait VirtioSoundProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<(u32, u32, u32, u32), fidl::Error>>
        + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        enable_input: bool,
        enable_verbose_logging: bool,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioSoundSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioSoundSynchronousProxy {
    type Proxy = VirtioSoundProxy;
    type Protocol = VirtioSoundMarker;

    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 VirtioSoundSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioSoundMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioSoundMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the sound device.
    /// The response contains the device's expected static configuration.
    ///
    /// + request `start_info` basic info to start the device
    /// + request `enable_input` whether audio input (capture) should be enabled
    /// + request `enable_verbose_logging` whether verbose logging should be enabled
    /// - response `features` supported features
    /// - response `jacks` the virtio_snd_config.jacks value to advertise
    /// - response `streams` the virtio_snd_config.streams value to advertise
    /// - response `chmaps` the virtio_snd_config.chaps value to advertise
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut enable_input: bool,
        mut enable_verbose_logging: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u32, u32, u32, u32), fidl::Error> {
        let _response = self
            .client
            .send_query::<VirtioSoundStartRequest, VirtioSoundStartResponse, VirtioSoundMarker>(
                (&mut start_info, enable_input, enable_verbose_logging),
                0x2c3a5528c0b92e2d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.features, _response.jacks, _response.streams, _response.chmaps))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioSoundProxy {
    type Protocol = VirtioSoundMarker;

    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 VirtioSoundProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioSound.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioSoundMarker 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) -> VirtioSoundEventStream {
        VirtioSoundEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioSoundProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioSoundProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioSoundProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the sound device.
    /// The response contains the device's expected static configuration.
    ///
    /// + request `start_info` basic info to start the device
    /// + request `enable_input` whether audio input (capture) should be enabled
    /// + request `enable_verbose_logging` whether verbose logging should be enabled
    /// - response `features` supported features
    /// - response `jacks` the virtio_snd_config.jacks value to advertise
    /// - response `streams` the virtio_snd_config.streams value to advertise
    /// - response `chmaps` the virtio_snd_config.chaps value to advertise
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut enable_input: bool,
        mut enable_verbose_logging: bool,
    ) -> fidl::client::QueryResponseFut<
        (u32, u32, u32, u32),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VirtioSoundProxyInterface::r#start(self, start_info, enable_input, enable_verbose_logging)
    }
}

impl VirtioSoundProxyInterface for VirtioSoundProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut = fidl::client::QueryResponseFut<
        (u32, u32, u32, u32),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut enable_input: bool,
        mut enable_verbose_logging: bool,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u32, u32, u32, u32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VirtioSoundStartResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c3a5528c0b92e2d,
            >(_buf?)?;
            Ok((_response.features, _response.jacks, _response.streams, _response.chmaps))
        }
        self.client.send_query_and_decode::<VirtioSoundStartRequest, (u32, u32, u32, u32)>(
            (&mut start_info, enable_input, enable_verbose_logging),
            0x2c3a5528c0b92e2d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioSound.
pub struct VirtioSoundRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioSoundRequestStream {
    type Protocol = VirtioSoundMarker;
    type ControlHandle = VirtioSoundControlHandle;

    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 {
        VirtioSoundControlHandle { 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 VirtioSoundRequestStream {
    type Item = Result<VirtioSoundRequest, 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 VirtioSoundRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioSoundControlHandle { inner: this.inner.clone() };
                        Ok(VirtioSoundRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioSoundConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioSoundControlHandle { inner: this.inner.clone() };
                        Ok(VirtioSoundRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioSoundControlHandle { inner: this.inner.clone() };
                        Ok(VirtioSoundRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioSoundReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c3a5528c0b92e2d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioSoundStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioSoundStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioSoundControlHandle { inner: this.inner.clone() };
                        Ok(VirtioSoundRequest::Start {
                            start_info: req.start_info,
                            enable_input: req.enable_input,
                            enable_verbose_logging: req.enable_verbose_logging,

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

#[derive(Debug)]
pub enum VirtioSoundRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioSoundConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioSoundControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioSoundReadyResponder },
    /// Start the sound device.
    /// The response contains the device's expected static configuration.
    ///
    /// + request `start_info` basic info to start the device
    /// + request `enable_input` whether audio input (capture) should be enabled
    /// + request `enable_verbose_logging` whether verbose logging should be enabled
    /// - response `features` supported features
    /// - response `jacks` the virtio_snd_config.jacks value to advertise
    /// - response `streams` the virtio_snd_config.streams value to advertise
    /// - response `chmaps` the virtio_snd_config.chaps value to advertise
    Start {
        start_info: StartInfo,
        enable_input: bool,
        enable_verbose_logging: bool,
        responder: VirtioSoundStartResponder,
    },
}

impl VirtioSoundRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioSoundConfigureQueueResponder)> {
        if let VirtioSoundRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioSoundControlHandle)> {
        if let VirtioSoundRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioSoundReadyResponder)> {
        if let VirtioSoundRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(StartInfo, bool, bool, VirtioSoundStartResponder)> {
        if let VirtioSoundRequest::Start {
            start_info,
            enable_input,
            enable_verbose_logging,
            responder,
        } = self
        {
            Some((start_info, enable_input, enable_verbose_logging, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioSoundRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioSoundRequest::NotifyQueue { .. } => "notify_queue",
            VirtioSoundRequest::Ready { .. } => "ready",
            VirtioSoundRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioSoundControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioSoundControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut features: u32,
        mut jacks: u32,
        mut streams: u32,
        mut chmaps: u32,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<VirtioSoundStartResponse>(
            (features, jacks, streams, chmaps),
            self.tx_id,
            0x2c3a5528c0b92e2d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VirtioVsockMarker {
    type Proxy = VirtioVsockProxy;
    type RequestStream = VirtioVsockRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtioVsockSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.hardware.VirtioVsock";
}
impl fidl::endpoints::DiscoverableProtocolMarker for VirtioVsockMarker {}
pub type VirtioVsockStartResult = Result<(), i32>;

pub trait VirtioVsockProxyInterface: Send + Sync {
    type ConfigureQueueResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#configure_queue(
        &self,
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
    ) -> Self::ConfigureQueueResponseFut;
    fn r#notify_queue(&self, queue: u16) -> Result<(), fidl::Error>;
    type ReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#ready(&self, negotiated_features: u32) -> Self::ReadyResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<VirtioVsockStartResult, fidl::Error>>
        + Send;
    fn r#start(
        &self,
        start_info: StartInfo,
        guest_cid: u32,
        listeners: Vec<fidl_fuchsia_virtualization::Listener>,
    ) -> Self::StartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtioVsockSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtioVsockSynchronousProxy {
    type Proxy = VirtioVsockProxy;
    type Protocol = VirtioVsockMarker;

    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 VirtioVsockSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceConfigureQueueRequest,
            fidl::encoding::EmptyPayload,
            VirtioVsockMarker,
        >(
            (queue, size, desc, avail, used,),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            VirtioDeviceReadyRequest,
            fidl::encoding::EmptyPayload,
            VirtioVsockMarker,
        >(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Start the vsock device, setting the guest_cid to the provided value.
    ///
    /// Returns:
    ///   - ZX_OK if device startup succeeded
    ///   - ZX_ERR_INVALID_ARGS if guest_cid is a reserved value
    ///   - Any errors returned from fuchsia.virtualization.HostVsockEndpoint::Listen
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut guest_cid: u32,
        mut listeners: Vec<fidl_fuchsia_virtualization::Listener>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VirtioVsockStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            VirtioVsockStartRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            VirtioVsockMarker,
        >(
            (&mut start_info, guest_cid, listeners.as_mut(),),
            0x56433562cf67ae0f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtioVsockProxy {
    type Protocol = VirtioVsockMarker;

    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 VirtioVsockProxy {
    /// Create a new Proxy for fuchsia.virtualization.hardware/VirtioVsock.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VirtioVsockMarker 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) -> VirtioVsockEventStream {
        VirtioVsockEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    pub fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioVsockProxyInterface::r#configure_queue(self, queue, size, desc, avail, used)
    }

    /// Notify a `queue` for the device. Primarily used for black-box testing.
    pub fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        VirtioVsockProxyInterface::r#notify_queue(self, queue)
    }

    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    pub fn r#ready(
        &self,
        mut negotiated_features: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        VirtioVsockProxyInterface::r#ready(self, negotiated_features)
    }

    /// Start the vsock device, setting the guest_cid to the provided value.
    ///
    /// Returns:
    ///   - ZX_OK if device startup succeeded
    ///   - ZX_ERR_INVALID_ARGS if guest_cid is a reserved value
    ///   - Any errors returned from fuchsia.virtualization.HostVsockEndpoint::Listen
    pub fn r#start(
        &self,
        mut start_info: StartInfo,
        mut guest_cid: u32,
        mut listeners: Vec<fidl_fuchsia_virtualization::Listener>,
    ) -> fidl::client::QueryResponseFut<
        VirtioVsockStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VirtioVsockProxyInterface::r#start(self, start_info, guest_cid, listeners)
    }
}

impl VirtioVsockProxyInterface for VirtioVsockProxy {
    type ConfigureQueueResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#configure_queue(
        &self,
        mut queue: u16,
        mut size: u16,
        mut desc: u64,
        mut avail: u64,
        mut used: u64,
    ) -> Self::ConfigureQueueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72b44fb963480b11,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceConfigureQueueRequest, ()>(
            (queue, size, desc, avail, used),
            0x72b44fb963480b11,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#notify_queue(&self, mut queue: u16) -> Result<(), fidl::Error> {
        self.client.send::<VirtioDeviceNotifyQueueRequest>(
            (queue,),
            0x6e3a61d652499244,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#ready(&self, mut negotiated_features: u32) -> Self::ReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45707654f5d23c3f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<VirtioDeviceReadyRequest, ()>(
            (negotiated_features,),
            0x45707654f5d23c3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut = fidl::client::QueryResponseFut<
        VirtioVsockStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(
        &self,
        mut start_info: StartInfo,
        mut guest_cid: u32,
        mut listeners: Vec<fidl_fuchsia_virtualization::Listener>,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VirtioVsockStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x56433562cf67ae0f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<VirtioVsockStartRequest, VirtioVsockStartResult>(
            (&mut start_info, guest_cid, listeners.as_mut()),
            0x56433562cf67ae0f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.virtualization.hardware/VirtioVsock.
pub struct VirtioVsockRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtioVsockRequestStream {
    type Protocol = VirtioVsockMarker;
    type ControlHandle = VirtioVsockControlHandle;

    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 {
        VirtioVsockControlHandle { 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 VirtioVsockRequestStream {
    type Item = Result<VirtioVsockRequest, 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 VirtioVsockRequestStream 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 {
                    0x72b44fb963480b11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceConfigureQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceConfigureQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioVsockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioVsockRequest::ConfigureQueue {
                            queue: req.queue,
                            size: req.size,
                            desc: req.desc,
                            avail: req.avail,
                            used: req.used,

                            responder: VirtioVsockConfigureQueueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e3a61d652499244 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceNotifyQueueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceNotifyQueueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioVsockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioVsockRequest::NotifyQueue { queue: req.queue, control_handle })
                    }
                    0x45707654f5d23c3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioDeviceReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioDeviceReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioVsockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioVsockRequest::Ready {
                            negotiated_features: req.negotiated_features,

                            responder: VirtioVsockReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56433562cf67ae0f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VirtioVsockStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtioVsockStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VirtioVsockControlHandle { inner: this.inner.clone() };
                        Ok(VirtioVsockRequest::Start {
                            start_info: req.start_info,
                            guest_cid: req.guest_cid,
                            listeners: req.listeners,

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

#[derive(Debug)]
pub enum VirtioVsockRequest {
    /// Configure a `queue` for the device. This specifies the `size` and the
    /// guest physical addresses of the queue: `desc`, `avail`, and `used`.
    ConfigureQueue {
        queue: u16,
        size: u16,
        desc: u64,
        avail: u64,
        used: u64,
        responder: VirtioVsockConfigureQueueResponder,
    },
    /// Notify a `queue` for the device. Primarily used for black-box testing.
    NotifyQueue { queue: u16, control_handle: VirtioVsockControlHandle },
    /// Ready a device. This provides the set of `negotiated_features` that the
    /// driver and device have agreed upon.
    Ready { negotiated_features: u32, responder: VirtioVsockReadyResponder },
    /// Start the vsock device, setting the guest_cid to the provided value.
    ///
    /// Returns:
    ///   - ZX_OK if device startup succeeded
    ///   - ZX_ERR_INVALID_ARGS if guest_cid is a reserved value
    ///   - Any errors returned from fuchsia.virtualization.HostVsockEndpoint::Listen
    Start {
        start_info: StartInfo,
        guest_cid: u32,
        listeners: Vec<fidl_fuchsia_virtualization::Listener>,
        responder: VirtioVsockStartResponder,
    },
}

impl VirtioVsockRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_queue(
        self,
    ) -> Option<(u16, u16, u64, u64, u64, VirtioVsockConfigureQueueResponder)> {
        if let VirtioVsockRequest::ConfigureQueue { queue, size, desc, avail, used, responder } =
            self
        {
            Some((queue, size, desc, avail, used, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_queue(self) -> Option<(u16, VirtioVsockControlHandle)> {
        if let VirtioVsockRequest::NotifyQueue { queue, control_handle } = self {
            Some((queue, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready(self) -> Option<(u32, VirtioVsockReadyResponder)> {
        if let VirtioVsockRequest::Ready { negotiated_features, responder } = self {
            Some((negotiated_features, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(
        StartInfo,
        u32,
        Vec<fidl_fuchsia_virtualization::Listener>,
        VirtioVsockStartResponder,
    )> {
        if let VirtioVsockRequest::Start { start_info, guest_cid, listeners, responder } = self {
            Some((start_info, guest_cid, listeners, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VirtioVsockRequest::ConfigureQueue { .. } => "configure_queue",
            VirtioVsockRequest::NotifyQueue { .. } => "notify_queue",
            VirtioVsockRequest::Ready { .. } => "ready",
            VirtioVsockRequest::Start { .. } => "start",
        }
    }
}

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

impl VirtioVsockControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VirtioVsockControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;

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

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

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

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

    unsafe impl fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut StartInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Trap as fidl::encoding::ValueTypeMarker>::borrow(&self.trap),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Guest, { fidl::ObjectType::GUEST.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.guest),
                    <fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.event),
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.vmo),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Trap, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Guest,
                        { fidl::ObjectType::GUEST.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 20, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for StartInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                trap: fidl::new_empty!(Trap, fidl::encoding::DefaultFuchsiaResourceDialect),
                guest: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Guest,
                            { fidl::ObjectType::GUEST.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                event: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Trap,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.trap,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Guest,
                        { fidl::ObjectType::GUEST.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.guest,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event, decoder, offset + 20, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioBlockStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                spec: fidl::new_empty!(
                    fidl_fuchsia_virtualization::BlockSpec,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            VirtioConsoleStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VirtioConsoleStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioConsoleStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VirtioConsoleStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <StartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.start_info,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.socket
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VirtioConsoleStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioConsoleStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioConsoleStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                StartInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.start_info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 32, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<VirtioGpuStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VirtioGpuStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioGpuStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VirtioGpuStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <StartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.start_info,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<
                                fidl_fuchsia_ui_input3::KeyboardListenerMarker,
                            >,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.keyboard_listener,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.mouse_source,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<VirtioGpuStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioGpuStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            self.2.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioGpuStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                keyboard_listener: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<
                                fidl_fuchsia_ui_input3::KeyboardListenerMarker,
                            >,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mouse_source: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                StartInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.start_info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.keyboard_listener,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mouse_source,
                decoder,
                offset + 36,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioInputStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                input_type: fidl::new_empty!(
                    InputType,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<VirtioMemStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VirtioMemStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioMemStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VirtioMemStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <StartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.start_info,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.region_addr),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.plugged_block_size),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.region_size),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<VirtioMemStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioMemStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            self.2.encode(encoder, offset + 40, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioMemStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                region_addr: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                plugged_block_size: fidl::new_empty!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                region_size: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<VirtioNetStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VirtioNetStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioNetStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VirtioNetStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <StartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.start_info,
                    ),
                    <fidl_fuchsia_net::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.mac_address,
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enable_bridge),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl_fuchsia_net::MacAddress,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<VirtioNetStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioNetStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            self.2.encode(encoder, offset + 38, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioNetStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mac_address: fidl::new_empty!(
                    fidl_fuchsia_net::MacAddress,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                enable_bridge: fidl::new_empty!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xff00000000000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                StartInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.start_info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_net::MacAddress,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mac_address,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.enable_bridge,
                decoder,
                offset + 38,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioSoundStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                enable_input: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
                enable_verbose_logging: fidl::new_empty!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            VirtioVsockStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VirtioVsockStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioVsockStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VirtioVsockStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <StartInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.start_info),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.guest_cid),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_virtualization::Listener> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.listeners),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_virtualization::Listener>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VirtioVsockStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VirtioVsockStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            self.2.encode(encoder, offset + 40, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VirtioVsockStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                start_info: fidl::new_empty!(
                    StartInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                guest_cid: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                listeners: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_virtualization::Listener>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                StartInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.start_info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.guest_cid,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_virtualization::Listener>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listeners,
                decoder,
                offset + 40,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl fidl::encoding::Encode<InputType, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut InputType
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InputType>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                InputType::Keyboard(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                InputType::Mouse(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for InputType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Keyboard(fidl::new_empty!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_ui_input3::KeyboardListenerMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let InputType::Keyboard(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = InputType::Keyboard(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ServerEnd<
                                    fidl_fuchsia_ui_input3::KeyboardListenerMarker,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let InputType::Keyboard(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ServerEnd<
                                    fidl_fuchsia_ui_input3::KeyboardListenerMarker,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let InputType::Mouse(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = InputType::Mouse(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<
                                    fidl_fuchsia_ui_pointer::MouseSourceMarker,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let InputType::Mouse(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<
                                    fidl_fuchsia_ui_pointer::MouseSourceMarker,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}