fidl_fuchsia_virtualization/

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

/// Properties describing a block device.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlockSpec {
    /// The ID used to identify the block device.
    pub id: String,
    /// The access mode for the block device.
    pub mode: BlockMode,
    /// The data format of the block device.
    pub format: BlockFormat,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GuestGetBalloonControllerRequest {
    pub controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GuestGetHostVsockEndpointRequest {
    pub endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GuestGetMemControllerRequest {
    pub controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
}

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GuestLifecycleBindRequest {
    pub guest: fidl::endpoints::ServerEnd<GuestMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct GuestLifecycleCreateRequest {
    pub guest_config: GuestConfig,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GuestManagerConnectRequest {
    pub controller: fidl::endpoints::ServerEnd<GuestMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct GuestManagerGetInfoResponse {
    pub guest_info: GuestInfo,
}

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

#[derive(Debug, PartialEq)]
pub struct GuestManagerLaunchRequest {
    pub guest_config: GuestConfig,
    pub controller: fidl::endpoints::ServerEnd<GuestMarker>,
}

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

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

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Listener {
    pub port: u32,
    pub acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
}

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

/// The configuration required to start up a guest. When adding a new field, consider updating
/// fuchsia.virtualization.GuestDescriptor which is an informational snapshot of this table.
#[derive(Debug, Default, PartialEq)]
pub struct GuestConfig {
    /// Type of kernel to load. Cannot be changed from the command-line.
    pub kernel_type: Option<KernelType>,
    /// File to load the kernel from. Cannot be changed from the command-line.
    pub kernel: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
    /// File to load the initial RAM disk from. Cannot be changed from the
    /// command-line.
    pub ramdisk: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
    /// File to load the dtb overlay for a Linux kernel from. Cannot be changed
    /// from the command-line.
    pub dtb_overlay: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
    /// Kernel command-line to use. Cannot be changed from the command-line.
    pub cmdline: Option<String>,
    /// Additional kernel command-lines to append to the main command-line.
    pub cmdline_add: Option<Vec<String>>,
    /// The number of CPUs to provide to a guest.
    pub cpus: Option<u8>,
    /// Amount of guest memory required, in bytes. This value may be rounded up depending on
    /// the system configuration.
    pub guest_memory: Option<u64>,
    /// A list of block devices to give a guest. Cannot be changed from the
    /// command-line.
    pub block_devices: Option<Vec<BlockSpec>>,
    /// A list of specifications for network devices.
    pub net_devices: Option<Vec<NetSpec>>,
    /// "11: wayland_device WaylandDevice" was removed
    /// "12: magma_device MagmaDevice" was removed
    /// Whether to add a default network device.
    pub default_net: Option<bool>,
    /// Enable virtio-balloon.
    pub virtio_balloon: Option<bool>,
    /// Enable virtio-console.
    pub virtio_console: Option<bool>,
    /// Enable virtio-gpu.
    pub virtio_gpu: Option<bool>,
    /// Enable virtio-rng.
    pub virtio_rng: Option<bool>,
    /// Enable virtio-vsock.
    pub virtio_vsock: Option<bool>,
    /// Enable virtio-sound.
    pub virtio_sound: Option<bool>,
    /// Enable input streams (capture) for virtio-sound.
    pub virtio_sound_input: Option<bool>,
    /// Host ports to listen for guest initiated vsock connections on. This can be used for
    /// simplicity if a Listener is known at config creation time, or if a Listener must be
    /// available at the moment of guest creation for timing reasons.
    ///
    /// To add a Listener after a guest starts, see HostVsockEndpoint::Listen.
    pub vsock_listeners: Option<Vec<Listener>>,
    /// Enable virtio-mem
    pub virtio_mem: Option<bool>,
    /// Size of the dynamically (un)pluggable memory block.
    /// Memory can be (un)plugged at this granularity.
    /// Smaller block size increases changes of successful unplug at the cost of increasing
    /// the size of tracking bitmap.
    pub virtio_mem_block_size: Option<u64>,
    /// Size of the entire dynamically pluggable memory region
    pub virtio_mem_region_size: Option<u64>,
    /// Required alignment of the dynamically pluggable memory region
    pub virtio_mem_region_alignment: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum BlockFormat {
    /// File IO. All reads and writes go directly to disk as a flat file.
    File(fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>),
    /// QCOW image. All reads and writes go to a QCOW image.
    Qcow(fidl::Channel),
    /// Block IO. All reads and writes go to a block server.
    Block(fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>),
}

impl BlockFormat {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::File(_) => 1,
            Self::Qcow(_) => 2,
            Self::Block(_) => 3,
        }
    }
}

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

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

impl fidl::endpoints::ProtocolMarker for AndroidGuestManagerMarker {
    type Proxy = AndroidGuestManagerProxy;
    type RequestStream = AndroidGuestManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AndroidGuestManagerSynchronousProxy;

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

pub trait AndroidGuestManagerProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<GuestManagerLaunchResult, fidl::Error>>
        + Send;
    fn r#launch(
        &self,
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut;
    type ForceShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#force_shutdown(&self) -> Self::ForceShutdownResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<GuestManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<GuestInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AndroidGuestManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AndroidGuestManagerSynchronousProxy {
    type Proxy = AndroidGuestManagerProxy;
    type Protocol = AndroidGuestManagerMarker;

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

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerLaunchResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerLaunchRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, AndroidGuestManagerMarker>(
                (&mut guest_config, controller),
                0x394a2e29f750323e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            AndroidGuestManagerMarker,
        >(
            (),
            0x3ad9a012982f872d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, AndroidGuestManagerMarker>(
                (controller,),
                0x4e489076e3bb15b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Query guest info
    pub fn r#get_info(&self, ___deadline: zx::MonotonicInstant) -> Result<GuestInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            GuestManagerGetInfoResponse,
            AndroidGuestManagerMarker,
        >(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.guest_info)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AndroidGuestManagerProxy {
    type Protocol = AndroidGuestManagerMarker;

    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 AndroidGuestManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/AndroidGuestManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AndroidGuestManagerMarker 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) -> AndroidGuestManagerEventStream {
        AndroidGuestManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AndroidGuestManagerProxyInterface::r#launch(self, guest_config, controller)
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AndroidGuestManagerProxyInterface::r#force_shutdown(self)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AndroidGuestManagerProxyInterface::r#connect(self, controller)
    }

    /// Query guest info
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AndroidGuestManagerProxyInterface::r#get_info(self)
    }
}

impl AndroidGuestManagerProxyInterface for AndroidGuestManagerProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerLaunchResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x394a2e29f750323e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerLaunchRequest, GuestManagerLaunchResult>(
            (&mut guest_config, controller),
            0x394a2e29f750323e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e489076e3bb15b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerConnectRequest, GuestManagerConnectResult>(
            (controller,),
            0x4e489076e3bb15b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                GuestManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76892614aea695dc,
            >(_buf?)?;
            Ok(_response.guest_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestInfo>(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AndroidGuestManagerRequestStream {
    type Protocol = AndroidGuestManagerMarker;
    type ControlHandle = AndroidGuestManagerControlHandle;

    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 {
        AndroidGuestManagerControlHandle { 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 AndroidGuestManagerRequestStream {
    type Item = Result<AndroidGuestManagerRequest, 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 AndroidGuestManagerRequestStream 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 {
                0x394a2e29f750323e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerLaunchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AndroidGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AndroidGuestManagerRequest::Launch {guest_config: req.guest_config,
controller: req.controller,

                        responder: AndroidGuestManagerLaunchResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ad9a012982f872d => {
                    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 = AndroidGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AndroidGuestManagerRequest::ForceShutdown {
                        responder: AndroidGuestManagerForceShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4e489076e3bb15b4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AndroidGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AndroidGuestManagerRequest::Connect {controller: req.controller,

                        responder: AndroidGuestManagerConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76892614aea695dc => {
                    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 = AndroidGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AndroidGuestManagerRequest::GetInfo {
                        responder: AndroidGuestManagerGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <AndroidGuestManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum AndroidGuestManagerRequest {
    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    Launch {
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: AndroidGuestManagerLaunchResponder,
    },
    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    ForceShutdown { responder: AndroidGuestManagerForceShutdownResponder },
    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    Connect {
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: AndroidGuestManagerConnectResponder,
    },
    /// Query guest info
    GetInfo { responder: AndroidGuestManagerGetInfoResponder },
}

impl AndroidGuestManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(
        self,
    ) -> Option<(
        GuestConfig,
        fidl::endpoints::ServerEnd<GuestMarker>,
        AndroidGuestManagerLaunchResponder,
    )> {
        if let AndroidGuestManagerRequest::Launch { guest_config, controller, responder } = self {
            Some((guest_config, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_shutdown(self) -> Option<(AndroidGuestManagerForceShutdownResponder)> {
        if let AndroidGuestManagerRequest::ForceShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, AndroidGuestManagerConnectResponder)>
    {
        if let AndroidGuestManagerRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(AndroidGuestManagerGetInfoResponder)> {
        if let AndroidGuestManagerRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AndroidGuestManagerRequest::Launch { .. } => "launch",
            AndroidGuestManagerRequest::ForceShutdown { .. } => "force_shutdown",
            AndroidGuestManagerRequest::Connect { .. } => "connect",
            AndroidGuestManagerRequest::GetInfo { .. } => "get_info",
        }
    }
}

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

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

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

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

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

impl AndroidGuestManagerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut guest_info: &GuestInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestManagerGetInfoResponse>(
            (guest_info,),
            self.tx_id,
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BalloonControllerMarker {
    type Proxy = BalloonControllerProxy;
    type RequestStream = BalloonControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BalloonControllerSynchronousProxy;

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

pub trait BalloonControllerProxyInterface: Send + Sync {
    type GetBalloonSizeResponseFut: std::future::Future<Output = Result<(u32, u32), fidl::Error>>
        + Send;
    fn r#get_balloon_size(&self) -> Self::GetBalloonSizeResponseFut;
    fn r#request_num_pages(&self, requested_num_pages: u32) -> Result<(), fidl::Error>;
    type GetMemStatsResponseFut: std::future::Future<Output = Result<(i32, Option<Vec<MemStat>>), fidl::Error>>
        + Send;
    fn r#get_mem_stats(&self) -> Self::GetMemStatsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BalloonControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BalloonControllerSynchronousProxy {
    type Proxy = BalloonControllerProxy;
    type Protocol = BalloonControllerMarker;

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

    /// Get the current and requested number of pages in the memory balloon.
    ///
    /// current_num_pages is the number of pages balloon has right now.
    /// requested_num_pages is the desired number of pages in the balloon.
    ///
    /// 'current_num_pages' corresponds to the 'actual' virtio-balloon config field
    /// 'requested_num_pages' corresponds to the 'num_pages' virtio-balloon config field.
    pub fn r#get_balloon_size(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u32, u32), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            BalloonControllerGetBalloonSizeResponse,
            BalloonControllerMarker,
        >(
            (),
            0x2bb2ebaa6ff64d0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.current_num_pages, _response.requested_num_pages))
    }

    /// Request a number of pages to be supplied to the memory balloon.
    ///
    /// If `requested_num_pages` is greater than the `current_num_pages` config
    /// value, the guest driver SHOULD provide additional pages to the memory balloon.
    /// If `requested_num_pages` is less than the 'current_num_pages' config value,
    /// the guest driver MAY reclaim pages from the memory balloon.
    pub fn r#request_num_pages(&self, mut requested_num_pages: u32) -> Result<(), fidl::Error> {
        self.client.send::<BalloonControllerRequestNumPagesRequest>(
            (requested_num_pages,),
            0x55c444d65e1df1e8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Get memory statistics of the guest instance.
    pub fn r#get_mem_stats(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Vec<MemStat>>), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            BalloonControllerGetMemStatsResponse,
            BalloonControllerMarker,
        >(
            (),
            0x676199795cc01142,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.mem_stats))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BalloonControllerProxy {
    type Protocol = BalloonControllerMarker;

    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 BalloonControllerProxy {
    /// Create a new Proxy for fuchsia.virtualization/BalloonController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <BalloonControllerMarker 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) -> BalloonControllerEventStream {
        BalloonControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get the current and requested number of pages in the memory balloon.
    ///
    /// current_num_pages is the number of pages balloon has right now.
    /// requested_num_pages is the desired number of pages in the balloon.
    ///
    /// 'current_num_pages' corresponds to the 'actual' virtio-balloon config field
    /// 'requested_num_pages' corresponds to the 'num_pages' virtio-balloon config field.
    pub fn r#get_balloon_size(
        &self,
    ) -> fidl::client::QueryResponseFut<(u32, u32), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BalloonControllerProxyInterface::r#get_balloon_size(self)
    }

    /// Request a number of pages to be supplied to the memory balloon.
    ///
    /// If `requested_num_pages` is greater than the `current_num_pages` config
    /// value, the guest driver SHOULD provide additional pages to the memory balloon.
    /// If `requested_num_pages` is less than the 'current_num_pages' config value,
    /// the guest driver MAY reclaim pages from the memory balloon.
    pub fn r#request_num_pages(&self, mut requested_num_pages: u32) -> Result<(), fidl::Error> {
        BalloonControllerProxyInterface::r#request_num_pages(self, requested_num_pages)
    }

    /// Get memory statistics of the guest instance.
    pub fn r#get_mem_stats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Vec<MemStat>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BalloonControllerProxyInterface::r#get_mem_stats(self)
    }
}

impl BalloonControllerProxyInterface for BalloonControllerProxy {
    type GetBalloonSizeResponseFut =
        fidl::client::QueryResponseFut<(u32, u32), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_balloon_size(&self) -> Self::GetBalloonSizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u32, u32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BalloonControllerGetBalloonSizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2bb2ebaa6ff64d0b,
            >(_buf?)?;
            Ok((_response.current_num_pages, _response.requested_num_pages))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (u32, u32)>(
            (),
            0x2bb2ebaa6ff64d0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#request_num_pages(&self, mut requested_num_pages: u32) -> Result<(), fidl::Error> {
        self.client.send::<BalloonControllerRequestNumPagesRequest>(
            (requested_num_pages,),
            0x55c444d65e1df1e8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetMemStatsResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Vec<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<MemStat>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BalloonControllerGetMemStatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x676199795cc01142,
            >(_buf?)?;
            Ok((_response.status, _response.mem_stats))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<Vec<MemStat>>)>(
                (),
                0x676199795cc01142,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BalloonControllerRequestStream {
    type Protocol = BalloonControllerMarker;
    type ControlHandle = BalloonControllerControlHandle;

    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 {
        BalloonControllerControlHandle { 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 BalloonControllerRequestStream {
    type Item = Result<BalloonControllerRequest, 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 BalloonControllerRequestStream 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 {
                    0x2bb2ebaa6ff64d0b => {
                        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 =
                            BalloonControllerControlHandle { inner: this.inner.clone() };
                        Ok(BalloonControllerRequest::GetBalloonSize {
                            responder: BalloonControllerGetBalloonSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55c444d65e1df1e8 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            BalloonControllerRequestNumPagesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BalloonControllerRequestNumPagesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BalloonControllerControlHandle { inner: this.inner.clone() };
                        Ok(BalloonControllerRequest::RequestNumPages {
                            requested_num_pages: req.requested_num_pages,

                            control_handle,
                        })
                    }
                    0x676199795cc01142 => {
                        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 =
                            BalloonControllerControlHandle { inner: this.inner.clone() };
                        Ok(BalloonControllerRequest::GetMemStats {
                            responder: BalloonControllerGetMemStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BalloonControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A `BalloonController` controls a guest instance's memory balloon.
#[derive(Debug)]
pub enum BalloonControllerRequest {
    /// Get the current and requested number of pages in the memory balloon.
    ///
    /// current_num_pages is the number of pages balloon has right now.
    /// requested_num_pages is the desired number of pages in the balloon.
    ///
    /// 'current_num_pages' corresponds to the 'actual' virtio-balloon config field
    /// 'requested_num_pages' corresponds to the 'num_pages' virtio-balloon config field.
    GetBalloonSize { responder: BalloonControllerGetBalloonSizeResponder },
    /// Request a number of pages to be supplied to the memory balloon.
    ///
    /// If `requested_num_pages` is greater than the `current_num_pages` config
    /// value, the guest driver SHOULD provide additional pages to the memory balloon.
    /// If `requested_num_pages` is less than the 'current_num_pages' config value,
    /// the guest driver MAY reclaim pages from the memory balloon.
    RequestNumPages { requested_num_pages: u32, control_handle: BalloonControllerControlHandle },
    /// Get memory statistics of the guest instance.
    GetMemStats { responder: BalloonControllerGetMemStatsResponder },
}

impl BalloonControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_balloon_size(self) -> Option<(BalloonControllerGetBalloonSizeResponder)> {
        if let BalloonControllerRequest::GetBalloonSize { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_num_pages(self) -> Option<(u32, BalloonControllerControlHandle)> {
        if let BalloonControllerRequest::RequestNumPages { requested_num_pages, control_handle } =
            self
        {
            Some((requested_num_pages, control_handle))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BalloonControllerRequest::GetBalloonSize { .. } => "get_balloon_size",
            BalloonControllerRequest::RequestNumPages { .. } => "request_num_pages",
            BalloonControllerRequest::GetMemStats { .. } => "get_mem_stats",
        }
    }
}

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

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

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

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

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

impl BalloonControllerControlHandle {}

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

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

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

    fn send_raw(
        &self,
        mut current_num_pages: u32,
        mut requested_num_pages: u32,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BalloonControllerGetBalloonSizeResponse>(
            (current_num_pages, requested_num_pages),
            self.tx_id,
            0x2bb2ebaa6ff64d0b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &BalloonControllerControlHandle {
        &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 BalloonControllerGetMemStatsResponder {
    /// 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<&[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<&[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<&[MemStat]>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BalloonControllerGetMemStatsResponse>(
            (status, mem_stats),
            self.tx_id,
            0x676199795cc01142,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DebianGuestManagerMarker {
    type Proxy = DebianGuestManagerProxy;
    type RequestStream = DebianGuestManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DebianGuestManagerSynchronousProxy;

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

pub trait DebianGuestManagerProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<GuestManagerLaunchResult, fidl::Error>>
        + Send;
    fn r#launch(
        &self,
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut;
    type ForceShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#force_shutdown(&self) -> Self::ForceShutdownResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<GuestManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<GuestInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DebianGuestManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DebianGuestManagerSynchronousProxy {
    type Proxy = DebianGuestManagerProxy;
    type Protocol = DebianGuestManagerMarker;

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

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerLaunchResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerLaunchRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, DebianGuestManagerMarker>(
                (&mut guest_config, controller),
                0x394a2e29f750323e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            DebianGuestManagerMarker,
        >(
            (),
            0x3ad9a012982f872d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, DebianGuestManagerMarker>(
                (controller,),
                0x4e489076e3bb15b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Query guest info
    pub fn r#get_info(&self, ___deadline: zx::MonotonicInstant) -> Result<GuestInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            GuestManagerGetInfoResponse,
            DebianGuestManagerMarker,
        >(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.guest_info)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DebianGuestManagerProxy {
    type Protocol = DebianGuestManagerMarker;

    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 DebianGuestManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/DebianGuestManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DebianGuestManagerMarker 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) -> DebianGuestManagerEventStream {
        DebianGuestManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebianGuestManagerProxyInterface::r#launch(self, guest_config, controller)
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DebianGuestManagerProxyInterface::r#force_shutdown(self)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebianGuestManagerProxyInterface::r#connect(self, controller)
    }

    /// Query guest info
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DebianGuestManagerProxyInterface::r#get_info(self)
    }
}

impl DebianGuestManagerProxyInterface for DebianGuestManagerProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerLaunchResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x394a2e29f750323e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerLaunchRequest, GuestManagerLaunchResult>(
            (&mut guest_config, controller),
            0x394a2e29f750323e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e489076e3bb15b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerConnectRequest, GuestManagerConnectResult>(
            (controller,),
            0x4e489076e3bb15b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                GuestManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76892614aea695dc,
            >(_buf?)?;
            Ok(_response.guest_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestInfo>(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DebianGuestManagerRequestStream {
    type Protocol = DebianGuestManagerMarker;
    type ControlHandle = DebianGuestManagerControlHandle;

    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 {
        DebianGuestManagerControlHandle { 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 DebianGuestManagerRequestStream {
    type Item = Result<DebianGuestManagerRequest, 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 DebianGuestManagerRequestStream 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 {
                0x394a2e29f750323e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerLaunchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = DebianGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DebianGuestManagerRequest::Launch {guest_config: req.guest_config,
controller: req.controller,

                        responder: DebianGuestManagerLaunchResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ad9a012982f872d => {
                    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 = DebianGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DebianGuestManagerRequest::ForceShutdown {
                        responder: DebianGuestManagerForceShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4e489076e3bb15b4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = DebianGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DebianGuestManagerRequest::Connect {controller: req.controller,

                        responder: DebianGuestManagerConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76892614aea695dc => {
                    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 = DebianGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DebianGuestManagerRequest::GetInfo {
                        responder: DebianGuestManagerGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <DebianGuestManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum DebianGuestManagerRequest {
    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    Launch {
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: DebianGuestManagerLaunchResponder,
    },
    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    ForceShutdown { responder: DebianGuestManagerForceShutdownResponder },
    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    Connect {
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: DebianGuestManagerConnectResponder,
    },
    /// Query guest info
    GetInfo { responder: DebianGuestManagerGetInfoResponder },
}

impl DebianGuestManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(
        self,
    ) -> Option<(
        GuestConfig,
        fidl::endpoints::ServerEnd<GuestMarker>,
        DebianGuestManagerLaunchResponder,
    )> {
        if let DebianGuestManagerRequest::Launch { guest_config, controller, responder } = self {
            Some((guest_config, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_shutdown(self) -> Option<(DebianGuestManagerForceShutdownResponder)> {
        if let DebianGuestManagerRequest::ForceShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, DebianGuestManagerConnectResponder)> {
        if let DebianGuestManagerRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(DebianGuestManagerGetInfoResponder)> {
        if let DebianGuestManagerRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DebianGuestManagerRequest::Launch { .. } => "launch",
            DebianGuestManagerRequest::ForceShutdown { .. } => "force_shutdown",
            DebianGuestManagerRequest::Connect { .. } => "connect",
            DebianGuestManagerRequest::GetInfo { .. } => "get_info",
        }
    }
}

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

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

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

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

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

impl DebianGuestManagerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut guest_info: &GuestInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestManagerGetInfoResponse>(
            (guest_info,),
            self.tx_id,
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for GuestMarker {
    type Proxy = GuestProxy;
    type RequestStream = GuestRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = GuestSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.Guest";
}
impl fidl::endpoints::DiscoverableProtocolMarker for GuestMarker {}
pub type GuestGetConsoleResult = Result<fidl::Socket, GuestError>;
pub type GuestGetHostVsockEndpointResult = Result<(), GuestError>;
pub type GuestGetBalloonControllerResult = Result<(), GuestError>;
pub type GuestGetMemControllerResult = Result<(), GuestError>;

pub trait GuestProxyInterface: Send + Sync {
    type GetConsoleResponseFut: std::future::Future<Output = Result<GuestGetConsoleResult, fidl::Error>>
        + Send;
    fn r#get_console(&self) -> Self::GetConsoleResponseFut;
    type GetSerialResponseFut: std::future::Future<Output = Result<fidl::Socket, fidl::Error>>
        + Send;
    fn r#get_serial(&self) -> Self::GetSerialResponseFut;
    type GetHostVsockEndpointResponseFut: std::future::Future<Output = Result<GuestGetHostVsockEndpointResult, fidl::Error>>
        + Send;
    fn r#get_host_vsock_endpoint(
        &self,
        endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
    ) -> Self::GetHostVsockEndpointResponseFut;
    type GetBalloonControllerResponseFut: std::future::Future<Output = Result<GuestGetBalloonControllerResult, fidl::Error>>
        + Send;
    fn r#get_balloon_controller(
        &self,
        controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
    ) -> Self::GetBalloonControllerResponseFut;
    type GetMemControllerResponseFut: std::future::Future<Output = Result<GuestGetMemControllerResult, fidl::Error>>
        + Send;
    fn r#get_mem_controller(
        &self,
        controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
    ) -> Self::GetMemControllerResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct GuestSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for GuestSynchronousProxy {
    type Proxy = GuestProxy;
    type Protocol = GuestMarker;

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

    /// Get a guest console.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read/write socket
    /// with a shell.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a console device.
    pub fn r#get_console(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestGetConsoleResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<GuestGetConsoleResponse, GuestError>,
            GuestMarker,
        >(
            (),
            0x48cbcecb7793806e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.socket))
    }

    /// Get the socket for low-level guest debug logs.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read-only socket
    /// with the guest kernel's serial logs.
    pub fn r#get_serial(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Socket, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, GuestGetSerialResponse, GuestMarker>(
                (),
                0xcdd541a160d7044,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.socket)
    }

    /// Get the vsock endpoint for the guest.
    ///
    /// This endpoint can be used to register listeners for guest initiated connections, and
    /// to initiate connections from a client. If listeners need to be registered before the guest
    /// starts so that they are immediately available, set them via the guest config instead of
    /// using this endpoint.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a vsock device.
    pub fn r#get_host_vsock_endpoint(
        &self,
        mut endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestGetHostVsockEndpointResult, fidl::Error> {
        let _response = self.client.send_query::<
            GuestGetHostVsockEndpointRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
            GuestMarker,
        >(
            (endpoint,),
            0x766e96aeb9c28ed1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get the balloon controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a balloon device.
    pub fn r#get_balloon_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestGetBalloonControllerResult, fidl::Error> {
        let _response = self.client.send_query::<
            GuestGetBalloonControllerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
            GuestMarker,
        >(
            (controller,),
            0x7b210bff219ac84e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get the mem controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a mem device.
    pub fn r#get_mem_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestGetMemControllerResult, fidl::Error> {
        let _response = self.client.send_query::<
            GuestGetMemControllerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
            GuestMarker,
        >(
            (controller,),
            0x170b19f4b867a01c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for GuestProxy {
    type Protocol = GuestMarker;

    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 GuestProxy {
    /// Create a new Proxy for fuchsia.virtualization/Guest.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <GuestMarker 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) -> GuestEventStream {
        GuestEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get a guest console.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read/write socket
    /// with a shell.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a console device.
    pub fn r#get_console(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GuestGetConsoleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestProxyInterface::r#get_console(self)
    }

    /// Get the socket for low-level guest debug logs.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read-only socket
    /// with the guest kernel's serial logs.
    pub fn r#get_serial(
        &self,
    ) -> fidl::client::QueryResponseFut<fidl::Socket, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        GuestProxyInterface::r#get_serial(self)
    }

    /// Get the vsock endpoint for the guest.
    ///
    /// This endpoint can be used to register listeners for guest initiated connections, and
    /// to initiate connections from a client. If listeners need to be registered before the guest
    /// starts so that they are immediately available, set them via the guest config instead of
    /// using this endpoint.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a vsock device.
    pub fn r#get_host_vsock_endpoint(
        &self,
        mut endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestGetHostVsockEndpointResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestProxyInterface::r#get_host_vsock_endpoint(self, endpoint)
    }

    /// Get the balloon controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a balloon device.
    pub fn r#get_balloon_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestGetBalloonControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestProxyInterface::r#get_balloon_controller(self, controller)
    }

    /// Get the mem controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a mem device.
    pub fn r#get_mem_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestGetMemControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestProxyInterface::r#get_mem_controller(self, controller)
    }
}

impl GuestProxyInterface for GuestProxy {
    type GetConsoleResponseFut = fidl::client::QueryResponseFut<
        GuestGetConsoleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_console(&self) -> Self::GetConsoleResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestGetConsoleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<GuestGetConsoleResponse, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48cbcecb7793806e,
            >(_buf?)?;
            Ok(_response.map(|x| x.socket))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestGetConsoleResult>(
            (),
            0x48cbcecb7793806e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type GetHostVsockEndpointResponseFut = fidl::client::QueryResponseFut<
        GuestGetHostVsockEndpointResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_host_vsock_endpoint(
        &self,
        mut endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
    ) -> Self::GetHostVsockEndpointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestGetHostVsockEndpointResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x766e96aeb9c28ed1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            GuestGetHostVsockEndpointRequest,
            GuestGetHostVsockEndpointResult,
        >(
            (endpoint,),
            0x766e96aeb9c28ed1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBalloonControllerResponseFut = fidl::client::QueryResponseFut<
        GuestGetBalloonControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_balloon_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
    ) -> Self::GetBalloonControllerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestGetBalloonControllerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b210bff219ac84e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            GuestGetBalloonControllerRequest,
            GuestGetBalloonControllerResult,
        >(
            (controller,),
            0x7b210bff219ac84e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMemControllerResponseFut = fidl::client::QueryResponseFut<
        GuestGetMemControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mem_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
    ) -> Self::GetMemControllerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestGetMemControllerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x170b19f4b867a01c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<GuestGetMemControllerRequest, GuestGetMemControllerResult>(
                (controller,),
                0x170b19f4b867a01c,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for GuestRequestStream {
    type Protocol = GuestMarker;
    type ControlHandle = GuestControlHandle;

    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 {
        GuestControlHandle { 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 GuestRequestStream {
    type Item = Result<GuestRequest, 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 GuestRequestStream 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 {
                    0x48cbcecb7793806e => {
                        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 = GuestControlHandle { inner: this.inner.clone() };
                        Ok(GuestRequest::GetConsole {
                            responder: GuestGetConsoleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xcdd541a160d7044 => {
                        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 = GuestControlHandle { inner: this.inner.clone() };
                        Ok(GuestRequest::GetSerial {
                            responder: GuestGetSerialResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x766e96aeb9c28ed1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestGetHostVsockEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestGetHostVsockEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
                        Ok(GuestRequest::GetHostVsockEndpoint {
                            endpoint: req.endpoint,

                            responder: GuestGetHostVsockEndpointResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b210bff219ac84e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestGetBalloonControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestGetBalloonControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
                        Ok(GuestRequest::GetBalloonController {
                            controller: req.controller,

                            responder: GuestGetBalloonControllerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x170b19f4b867a01c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestGetMemControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestGetMemControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = GuestControlHandle { inner: this.inner.clone() };
                        Ok(GuestRequest::GetMemController {
                            controller: req.controller,

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

/// The guest client API providing high level access to guest features. When the guest terminates,
/// this channel will contain a ZX_OK epitaph on a clean shutdown, a ZX_ERR_INTERNAL epitaph on
/// an unexpected shutdown, and no epitaph if the component crashed.
#[derive(Debug)]
pub enum GuestRequest {
    /// Get a guest console.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read/write socket
    /// with a shell.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a console device.
    GetConsole { responder: GuestGetConsoleResponder },
    /// Get the socket for low-level guest debug logs.
    ///
    /// The details regarding what output is produced and what input is accepted
    /// are determined by each guest, but will typically be a read-only socket
    /// with the guest kernel's serial logs.
    GetSerial { responder: GuestGetSerialResponder },
    /// Get the vsock endpoint for the guest.
    ///
    /// This endpoint can be used to register listeners for guest initiated connections, and
    /// to initiate connections from a client. If listeners need to be registered before the guest
    /// starts so that they are immediately available, set them via the guest config instead of
    /// using this endpoint.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a vsock device.
    GetHostVsockEndpoint {
        endpoint: fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
        responder: GuestGetHostVsockEndpointResponder,
    },
    /// Get the balloon controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a balloon device.
    GetBalloonController {
        controller: fidl::endpoints::ServerEnd<BalloonControllerMarker>,
        responder: GuestGetBalloonControllerResponder,
    },
    /// Get the mem controller endpoint for the guest.
    ///
    /// Returns error DEVICE_NOT_PRESENT if the guest was started without a mem device.
    GetMemController {
        controller: fidl::endpoints::ServerEnd<MemControllerMarker>,
        responder: GuestGetMemControllerResponder,
    },
}

impl GuestRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_console(self) -> Option<(GuestGetConsoleResponder)> {
        if let GuestRequest::GetConsole { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_serial(self) -> Option<(GuestGetSerialResponder)> {
        if let GuestRequest::GetSerial { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_host_vsock_endpoint(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<HostVsockEndpointMarker>,
        GuestGetHostVsockEndpointResponder,
    )> {
        if let GuestRequest::GetHostVsockEndpoint { endpoint, responder } = self {
            Some((endpoint, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_balloon_controller(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<BalloonControllerMarker>,
        GuestGetBalloonControllerResponder,
    )> {
        if let GuestRequest::GetBalloonController { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mem_controller(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<MemControllerMarker>, GuestGetMemControllerResponder)>
    {
        if let GuestRequest::GetMemController { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            GuestRequest::GetConsole { .. } => "get_console",
            GuestRequest::GetSerial { .. } => "get_serial",
            GuestRequest::GetHostVsockEndpoint { .. } => "get_host_vsock_endpoint",
            GuestRequest::GetBalloonController { .. } => "get_balloon_controller",
            GuestRequest::GetMemController { .. } => "get_mem_controller",
        }
    }
}

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

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

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

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

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

impl GuestControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Socket, GuestError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<GuestGetConsoleResponse, GuestError>>(
                result.map(|socket| (socket,)),
                self.tx_id,
                0x48cbcecb7793806e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(&self, mut socket: fidl::Socket) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestGetSerialResponse>(
            (socket,),
            self.tx_id,
            0xcdd541a160d7044,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for GuestLifecycleMarker {
    type Proxy = GuestLifecycleProxy;
    type RequestStream = GuestLifecycleRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = GuestLifecycleSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.GuestLifecycle";
}
impl fidl::endpoints::DiscoverableProtocolMarker for GuestLifecycleMarker {}
pub type GuestLifecycleCreateResult = Result<(), GuestError>;
pub type GuestLifecycleRunResult = Result<(), GuestError>;

pub trait GuestLifecycleProxyInterface: Send + Sync {
    type CreateResponseFut: std::future::Future<Output = Result<GuestLifecycleCreateResult, fidl::Error>>
        + Send;
    fn r#create(&self, guest_config: GuestConfig) -> Self::CreateResponseFut;
    fn r#bind(&self, guest: fidl::endpoints::ServerEnd<GuestMarker>) -> Result<(), fidl::Error>;
    type RunResponseFut: std::future::Future<Output = Result<GuestLifecycleRunResult, fidl::Error>>
        + Send;
    fn r#run(&self) -> Self::RunResponseFut;
    type StopResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#stop(&self) -> Self::StopResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct GuestLifecycleSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for GuestLifecycleSynchronousProxy {
    type Proxy = GuestLifecycleProxy;
    type Protocol = GuestLifecycleMarker;

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

    /// Create a VMM configured with the provided config. This instantiates all devices and loads
    /// the kernel without starting the VCPU or device dispatch loops.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNNING: A VMM instance is already running, and must be stopped before being
    ///         recreated.
    ///
    /// All other errors are related to VMM initialization.
    pub fn r#create(
        &self,
        mut guest_config: GuestConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestLifecycleCreateResult, fidl::Error> {
        let _response = self.client.send_query::<
            GuestLifecycleCreateRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
            GuestLifecycleMarker,
        >(
            (&mut guest_config,),
            0x152719eed416ed41,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Binds to the Guest protocol for an initialized guest.
    ///
    /// This operation must be called between `Create` and `Stop`, otherwise the provided channel
    /// will be immediately closed.
    pub fn r#bind(
        &self,
        mut guest: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<GuestLifecycleBindRequest>(
            (guest,),
            0x57dd3e245f9598ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Start the primary VCPU and any dispatch loop. This will not return until the VMM stops
    /// running. On a clean shutdown (either guest or client initiated) this will return success.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNING: The VMM has already been started.
    ///     - NOT_CREATED: Run was called before the VMM was created.
    ///     - CONTROLLER_FORCED_HALT: Stop was called on a running VMM.
    ///     - VCPU_START_FAILURE: Failed to start the primary VCPU.
    ///     - VCPU_RUNTIME_FAILURE: A VCPU encountered a fatal error while running the guest.
    pub fn r#run(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestLifecycleRunResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
            GuestLifecycleMarker,
        >(
            (),
            0x2907fef2ac775657,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Stop a running VMM. Returns once the dispatch loops have stopped. After Stop returns,
    /// Create and then Run can be called again.
    pub fn r#stop(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            GuestLifecycleMarker,
        >(
            (),
            0x27eef9c535ac8eb4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for GuestLifecycleProxy {
    type Protocol = GuestLifecycleMarker;

    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 GuestLifecycleProxy {
    /// Create a new Proxy for fuchsia.virtualization/GuestLifecycle.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <GuestLifecycleMarker 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) -> GuestLifecycleEventStream {
        GuestLifecycleEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a VMM configured with the provided config. This instantiates all devices and loads
    /// the kernel without starting the VCPU or device dispatch loops.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNNING: A VMM instance is already running, and must be stopped before being
    ///         recreated.
    ///
    /// All other errors are related to VMM initialization.
    pub fn r#create(
        &self,
        mut guest_config: GuestConfig,
    ) -> fidl::client::QueryResponseFut<
        GuestLifecycleCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestLifecycleProxyInterface::r#create(self, guest_config)
    }

    /// Binds to the Guest protocol for an initialized guest.
    ///
    /// This operation must be called between `Create` and `Stop`, otherwise the provided channel
    /// will be immediately closed.
    pub fn r#bind(
        &self,
        mut guest: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Result<(), fidl::Error> {
        GuestLifecycleProxyInterface::r#bind(self, guest)
    }

    /// Start the primary VCPU and any dispatch loop. This will not return until the VMM stops
    /// running. On a clean shutdown (either guest or client initiated) this will return success.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNING: The VMM has already been started.
    ///     - NOT_CREATED: Run was called before the VMM was created.
    ///     - CONTROLLER_FORCED_HALT: Stop was called on a running VMM.
    ///     - VCPU_START_FAILURE: Failed to start the primary VCPU.
    ///     - VCPU_RUNTIME_FAILURE: A VCPU encountered a fatal error while running the guest.
    pub fn r#run(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GuestLifecycleRunResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestLifecycleProxyInterface::r#run(self)
    }

    /// Stop a running VMM. Returns once the dispatch loops have stopped. After Stop returns,
    /// Create and then Run can be called again.
    pub fn r#stop(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        GuestLifecycleProxyInterface::r#stop(self)
    }
}

impl GuestLifecycleProxyInterface for GuestLifecycleProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        GuestLifecycleCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create(&self, mut guest_config: GuestConfig) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestLifecycleCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x152719eed416ed41,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<GuestLifecycleCreateRequest, GuestLifecycleCreateResult>(
                (&mut guest_config,),
                0x152719eed416ed41,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#bind(
        &self,
        mut guest: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<GuestLifecycleBindRequest>(
            (guest,),
            0x57dd3e245f9598ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type RunResponseFut = fidl::client::QueryResponseFut<
        GuestLifecycleRunResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#run(&self) -> Self::RunResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestLifecycleRunResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2907fef2ac775657,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestLifecycleRunResult>(
            (),
            0x2907fef2ac775657,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for GuestLifecycleRequestStream {
    type Protocol = GuestLifecycleMarker;
    type ControlHandle = GuestLifecycleControlHandle;

    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 {
        GuestLifecycleControlHandle { 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 GuestLifecycleRequestStream {
    type Item = Result<GuestLifecycleRequest, 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 GuestLifecycleRequestStream 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 {
                    0x152719eed416ed41 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestLifecycleCreateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestLifecycleCreateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            GuestLifecycleControlHandle { inner: this.inner.clone() };
                        Ok(GuestLifecycleRequest::Create {
                            guest_config: req.guest_config,

                            responder: GuestLifecycleCreateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57dd3e245f9598ed => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            GuestLifecycleBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestLifecycleBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            GuestLifecycleControlHandle { inner: this.inner.clone() };
                        Ok(GuestLifecycleRequest::Bind { guest: req.guest, control_handle })
                    }
                    0x2907fef2ac775657 => {
                        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 =
                            GuestLifecycleControlHandle { inner: this.inner.clone() };
                        Ok(GuestLifecycleRequest::Run {
                            responder: GuestLifecycleRunResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x27eef9c535ac8eb4 => {
                        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 =
                            GuestLifecycleControlHandle { inner: this.inner.clone() };
                        Ok(GuestLifecycleRequest::Stop {
                            responder: GuestLifecycleStopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <GuestLifecycleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The guest control plane allowing for creating, starting, and stopping the guest.
#[derive(Debug)]
pub enum GuestLifecycleRequest {
    /// Create a VMM configured with the provided config. This instantiates all devices and loads
    /// the kernel without starting the VCPU or device dispatch loops.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNNING: A VMM instance is already running, and must be stopped before being
    ///         recreated.
    ///
    /// All other errors are related to VMM initialization.
    Create { guest_config: GuestConfig, responder: GuestLifecycleCreateResponder },
    /// Binds to the Guest protocol for an initialized guest.
    ///
    /// This operation must be called between `Create` and `Stop`, otherwise the provided channel
    /// will be immediately closed.
    Bind {
        guest: fidl::endpoints::ServerEnd<GuestMarker>,
        control_handle: GuestLifecycleControlHandle,
    },
    /// Start the primary VCPU and any dispatch loop. This will not return until the VMM stops
    /// running. On a clean shutdown (either guest or client initiated) this will return success.
    ///
    /// Possible errors:
    ///     - ALREADY_RUNING: The VMM has already been started.
    ///     - NOT_CREATED: Run was called before the VMM was created.
    ///     - CONTROLLER_FORCED_HALT: Stop was called on a running VMM.
    ///     - VCPU_START_FAILURE: Failed to start the primary VCPU.
    ///     - VCPU_RUNTIME_FAILURE: A VCPU encountered a fatal error while running the guest.
    Run { responder: GuestLifecycleRunResponder },
    /// Stop a running VMM. Returns once the dispatch loops have stopped. After Stop returns,
    /// Create and then Run can be called again.
    Stop { responder: GuestLifecycleStopResponder },
}

impl GuestLifecycleRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(self) -> Option<(GuestConfig, GuestLifecycleCreateResponder)> {
        if let GuestLifecycleRequest::Create { guest_config, responder } = self {
            Some((guest_config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, GuestLifecycleControlHandle)> {
        if let GuestLifecycleRequest::Bind { guest, control_handle } = self {
            Some((guest, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_run(self) -> Option<(GuestLifecycleRunResponder)> {
        if let GuestLifecycleRequest::Run { responder } = self { Some((responder)) } else { None }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            GuestLifecycleRequest::Create { .. } => "create",
            GuestLifecycleRequest::Bind { .. } => "bind",
            GuestLifecycleRequest::Run { .. } => "run",
            GuestLifecycleRequest::Stop { .. } => "stop",
        }
    }
}

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

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

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

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

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

impl GuestLifecycleControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for GuestManagerMarker {
    type Proxy = GuestManagerProxy;
    type RequestStream = GuestManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = GuestManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.GuestManager";
}
impl fidl::endpoints::DiscoverableProtocolMarker for GuestManagerMarker {}
pub type GuestManagerLaunchResult = Result<(), GuestManagerError>;
pub type GuestManagerConnectResult = Result<(), GuestManagerError>;

pub trait GuestManagerProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<GuestManagerLaunchResult, fidl::Error>>
        + Send;
    fn r#launch(
        &self,
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut;
    type ForceShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#force_shutdown(&self) -> Self::ForceShutdownResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<GuestManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<GuestInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct GuestManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for GuestManagerSynchronousProxy {
    type Proxy = GuestManagerProxy;
    type Protocol = GuestManagerMarker;

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

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerLaunchResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerLaunchRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, GuestManagerMarker>(
                (&mut guest_config, controller),
                0x394a2e29f750323e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            GuestManagerMarker,
        >(
            (),
            0x3ad9a012982f872d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, GuestManagerMarker>(
                (controller,),
                0x4e489076e3bb15b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Query guest info
    pub fn r#get_info(&self, ___deadline: zx::MonotonicInstant) -> Result<GuestInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            GuestManagerGetInfoResponse,
            GuestManagerMarker,
        >(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.guest_info)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for GuestManagerProxy {
    type Protocol = GuestManagerMarker;

    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 GuestManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/GuestManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <GuestManagerMarker 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) -> GuestManagerEventStream {
        GuestManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestManagerProxyInterface::r#launch(self, guest_config, controller)
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        GuestManagerProxyInterface::r#force_shutdown(self)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GuestManagerProxyInterface::r#connect(self, controller)
    }

    /// Query guest info
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        GuestManagerProxyInterface::r#get_info(self)
    }
}

impl GuestManagerProxyInterface for GuestManagerProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerLaunchResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x394a2e29f750323e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerLaunchRequest, GuestManagerLaunchResult>(
            (&mut guest_config, controller),
            0x394a2e29f750323e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e489076e3bb15b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerConnectRequest, GuestManagerConnectResult>(
            (controller,),
            0x4e489076e3bb15b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                GuestManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76892614aea695dc,
            >(_buf?)?;
            Ok(_response.guest_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestInfo>(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for GuestManagerRequestStream {
    type Protocol = GuestManagerMarker;
    type ControlHandle = GuestManagerControlHandle;

    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 {
        GuestManagerControlHandle { 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 GuestManagerRequestStream {
    type Item = Result<GuestManagerRequest, 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 GuestManagerRequestStream 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 {
                    0x394a2e29f750323e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestManagerLaunchRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            GuestManagerControlHandle { inner: this.inner.clone() };
                        Ok(GuestManagerRequest::Launch {
                            guest_config: req.guest_config,
                            controller: req.controller,

                            responder: GuestManagerLaunchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ad9a012982f872d => {
                        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 =
                            GuestManagerControlHandle { inner: this.inner.clone() };
                        Ok(GuestManagerRequest::ForceShutdown {
                            responder: GuestManagerForceShutdownResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e489076e3bb15b4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GuestManagerConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            GuestManagerControlHandle { inner: this.inner.clone() };
                        Ok(GuestManagerRequest::Connect {
                            controller: req.controller,

                            responder: GuestManagerConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x76892614aea695dc => {
                        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 =
                            GuestManagerControlHandle { inner: this.inner.clone() };
                        Ok(GuestManagerRequest::GetInfo {
                            responder: GuestManagerGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <GuestManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum GuestManagerRequest {
    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    Launch {
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: GuestManagerLaunchResponder,
    },
    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    ForceShutdown { responder: GuestManagerForceShutdownResponder },
    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    Connect {
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: GuestManagerConnectResponder,
    },
    /// Query guest info
    GetInfo { responder: GuestManagerGetInfoResponder },
}

impl GuestManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(
        self,
    ) -> Option<(GuestConfig, fidl::endpoints::ServerEnd<GuestMarker>, GuestManagerLaunchResponder)>
    {
        if let GuestManagerRequest::Launch { guest_config, controller, responder } = self {
            Some((guest_config, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_shutdown(self) -> Option<(GuestManagerForceShutdownResponder)> {
        if let GuestManagerRequest::ForceShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, GuestManagerConnectResponder)> {
        if let GuestManagerRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(GuestManagerGetInfoResponder)> {
        if let GuestManagerRequest::GetInfo { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            GuestManagerRequest::Launch { .. } => "launch",
            GuestManagerRequest::ForceShutdown { .. } => "force_shutdown",
            GuestManagerRequest::Connect { .. } => "connect",
            GuestManagerRequest::GetInfo { .. } => "get_info",
        }
    }
}

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

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

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

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

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

impl GuestManagerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut guest_info: &GuestInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestManagerGetInfoResponse>(
            (guest_info,),
            self.tx_id,
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for HostVsockAcceptorMarker {
    type Proxy = HostVsockAcceptorProxy;
    type RequestStream = HostVsockAcceptorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HostVsockAcceptorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) HostVsockAcceptor";
}
pub type HostVsockAcceptorAcceptResult = Result<fidl::Socket, i32>;

pub trait HostVsockAcceptorProxyInterface: Send + Sync {
    type AcceptResponseFut: std::future::Future<Output = Result<HostVsockAcceptorAcceptResult, fidl::Error>>
        + Send;
    fn r#accept(&self, src_cid: u32, src_port: u32, port: u32) -> Self::AcceptResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HostVsockAcceptorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HostVsockAcceptorSynchronousProxy {
    type Proxy = HostVsockAcceptorProxy;
    type Protocol = HostVsockAcceptorMarker;

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

    pub fn r#accept(
        &self,
        mut src_cid: u32,
        mut src_port: u32,
        mut port: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HostVsockAcceptorAcceptResult, fidl::Error> {
        let _response = self.client.send_query::<
            HostVsockAcceptorAcceptRequest,
            fidl::encoding::ResultType<HostVsockAcceptorAcceptResponse, i32>,
            HostVsockAcceptorMarker,
        >(
            (src_cid, src_port, port,),
            0x6996ed935beaa2d7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.socket))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HostVsockAcceptorProxy {
    type Protocol = HostVsockAcceptorMarker;

    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 HostVsockAcceptorProxy {
    /// Create a new Proxy for fuchsia.virtualization/HostVsockAcceptor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <HostVsockAcceptorMarker 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) -> HostVsockAcceptorEventStream {
        HostVsockAcceptorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#accept(
        &self,
        mut src_cid: u32,
        mut src_port: u32,
        mut port: u32,
    ) -> fidl::client::QueryResponseFut<
        HostVsockAcceptorAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HostVsockAcceptorProxyInterface::r#accept(self, src_cid, src_port, port)
    }
}

impl HostVsockAcceptorProxyInterface for HostVsockAcceptorProxy {
    type AcceptResponseFut = fidl::client::QueryResponseFut<
        HostVsockAcceptorAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#accept(
        &self,
        mut src_cid: u32,
        mut src_port: u32,
        mut port: u32,
    ) -> Self::AcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HostVsockAcceptorAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<HostVsockAcceptorAcceptResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6996ed935beaa2d7,
            >(_buf?)?;
            Ok(_response.map(|x| x.socket))
        }
        self.client
            .send_query_and_decode::<HostVsockAcceptorAcceptRequest, HostVsockAcceptorAcceptResult>(
                (src_cid, src_port, port),
                0x6996ed935beaa2d7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for HostVsockAcceptorRequestStream {
    type Protocol = HostVsockAcceptorMarker;
    type ControlHandle = HostVsockAcceptorControlHandle;

    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 {
        HostVsockAcceptorControlHandle { 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 HostVsockAcceptorRequestStream {
    type Item = Result<HostVsockAcceptorRequest, 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 HostVsockAcceptorRequestStream 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 {
                    0x6996ed935beaa2d7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HostVsockAcceptorAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HostVsockAcceptorAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HostVsockAcceptorControlHandle { inner: this.inner.clone() };
                        Ok(HostVsockAcceptorRequest::Accept {
                            src_cid: req.src_cid,
                            src_port: req.src_port,
                            port: req.port,

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

/// Exposed by a host capable of listening via vsocks. A variant of a
/// `GuestVsockAcceptor` that is responsible for creating the `socket` with which
/// to communicate.
#[derive(Debug)]
pub enum HostVsockAcceptorRequest {
    Accept { src_cid: u32, src_port: u32, port: u32, responder: HostVsockAcceptorAcceptResponder },
}

impl HostVsockAcceptorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(self) -> Option<(u32, u32, u32, HostVsockAcceptorAcceptResponder)> {
        if let HostVsockAcceptorRequest::Accept { src_cid, src_port, port, responder } = self {
            Some((src_cid, src_port, port, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl HostVsockAcceptorControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Socket, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<HostVsockAcceptorAcceptResponse, i32>>(
                result.map(|socket| (socket,)),
                self.tx_id,
                0x6996ed935beaa2d7,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for HostVsockEndpointMarker {
    type Proxy = HostVsockEndpointProxy;
    type RequestStream = HostVsockEndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HostVsockEndpointSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.HostVsockEndpoint";
}
impl fidl::endpoints::DiscoverableProtocolMarker for HostVsockEndpointMarker {}
pub type HostVsockEndpointListenResult = Result<(), i32>;
pub type HostVsockEndpointConnectResult = Result<fidl::Socket, i32>;

pub trait HostVsockEndpointProxyInterface: Send + Sync {
    type ListenResponseFut: std::future::Future<Output = Result<HostVsockEndpointListenResult, fidl::Error>>
        + Send;
    fn r#listen(
        &self,
        port: u32,
        acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
    ) -> Self::ListenResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<HostVsockEndpointConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, guest_port: u32) -> Self::ConnectResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HostVsockEndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HostVsockEndpointSynchronousProxy {
    type Proxy = HostVsockEndpointProxy;
    type Protocol = HostVsockEndpointMarker;

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

    /// Instructs the device to listen for guest initiated connections to a given port by
    /// using `acceptor` when the guest creates a connection.
    ///
    /// Possible errors:
    ///     - ZX_ERR_ALREADY_BOUND: A client is already listening on this port.
    pub fn r#listen(
        &self,
        mut port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HostVsockEndpointListenResult, fidl::Error> {
        let _response = self.client.send_query::<
            Listener,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            HostVsockEndpointMarker,
        >(
            (port, acceptor,),
            0xfd88f3b4767f2c7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Attempts to create a vsock connection to a guest on 'guest_port'. Uses a dynamically chosen
    /// ephemeral host port.
    ///
    /// Possible errors:
    ///     - ZX_ERR_NO_RESOURCES: The device couldn't allocate an unused host port.
    ///     - ZX_ERR_CONNECTION_REFUSED: The guest refused this connection.
    ///
    /// Other errors are related to socket creation, see
    /// [zx_socket_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/socket_create.md)
    pub fn r#connect(
        &self,
        mut guest_port: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HostVsockEndpointConnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            HostVsockEndpointConnectRequest,
            fidl::encoding::ResultType<HostVsockEndpointConnectResponse, i32>,
            HostVsockEndpointMarker,
        >(
            (guest_port,),
            0x4d12e10e946b43e4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.socket))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HostVsockEndpointProxy {
    type Protocol = HostVsockEndpointMarker;

    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 HostVsockEndpointProxy {
    /// Create a new Proxy for fuchsia.virtualization/HostVsockEndpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <HostVsockEndpointMarker 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) -> HostVsockEndpointEventStream {
        HostVsockEndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Instructs the device to listen for guest initiated connections to a given port by
    /// using `acceptor` when the guest creates a connection.
    ///
    /// Possible errors:
    ///     - ZX_ERR_ALREADY_BOUND: A client is already listening on this port.
    pub fn r#listen(
        &self,
        mut port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
    ) -> fidl::client::QueryResponseFut<
        HostVsockEndpointListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HostVsockEndpointProxyInterface::r#listen(self, port, acceptor)
    }

    /// Attempts to create a vsock connection to a guest on 'guest_port'. Uses a dynamically chosen
    /// ephemeral host port.
    ///
    /// Possible errors:
    ///     - ZX_ERR_NO_RESOURCES: The device couldn't allocate an unused host port.
    ///     - ZX_ERR_CONNECTION_REFUSED: The guest refused this connection.
    ///
    /// Other errors are related to socket creation, see
    /// [zx_socket_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/socket_create.md)
    pub fn r#connect(
        &self,
        mut guest_port: u32,
    ) -> fidl::client::QueryResponseFut<
        HostVsockEndpointConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HostVsockEndpointProxyInterface::r#connect(self, guest_port)
    }
}

impl HostVsockEndpointProxyInterface for HostVsockEndpointProxy {
    type ListenResponseFut = fidl::client::QueryResponseFut<
        HostVsockEndpointListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen(
        &self,
        mut port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
    ) -> Self::ListenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HostVsockEndpointListenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xfd88f3b4767f2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Listener, HostVsockEndpointListenResult>(
            (port, acceptor),
            0xfd88f3b4767f2c7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        HostVsockEndpointConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut guest_port: u32) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HostVsockEndpointConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<HostVsockEndpointConnectResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4d12e10e946b43e4,
            >(_buf?)?;
            Ok(_response.map(|x| x.socket))
        }
        self.client.send_query_and_decode::<
            HostVsockEndpointConnectRequest,
            HostVsockEndpointConnectResult,
        >(
            (guest_port,),
            0x4d12e10e946b43e4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for HostVsockEndpointRequestStream {
    type Protocol = HostVsockEndpointMarker;
    type ControlHandle = HostVsockEndpointControlHandle;

    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 {
        HostVsockEndpointControlHandle { 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 HostVsockEndpointRequestStream {
    type Item = Result<HostVsockEndpointRequest, 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 HostVsockEndpointRequestStream 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 {
                    0xfd88f3b4767f2c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            Listener,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Listener>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HostVsockEndpointControlHandle { inner: this.inner.clone() };
                        Ok(HostVsockEndpointRequest::Listen {
                            port: req.port,
                            acceptor: req.acceptor,

                            responder: HostVsockEndpointListenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4d12e10e946b43e4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HostVsockEndpointConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HostVsockEndpointConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HostVsockEndpointControlHandle { inner: this.inner.clone() };
                        Ok(HostVsockEndpointRequest::Connect {
                            guest_port: req.guest_port,

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

/// Exposed by a host to provide the ability for listeners to be multiplexed by
/// port and to manage dynamic port allocation for outbound connections.
#[derive(Debug)]
pub enum HostVsockEndpointRequest {
    /// Instructs the device to listen for guest initiated connections to a given port by
    /// using `acceptor` when the guest creates a connection.
    ///
    /// Possible errors:
    ///     - ZX_ERR_ALREADY_BOUND: A client is already listening on this port.
    Listen {
        port: u32,
        acceptor: fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
        responder: HostVsockEndpointListenResponder,
    },
    /// Attempts to create a vsock connection to a guest on 'guest_port'. Uses a dynamically chosen
    /// ephemeral host port.
    ///
    /// Possible errors:
    ///     - ZX_ERR_NO_RESOURCES: The device couldn't allocate an unused host port.
    ///     - ZX_ERR_CONNECTION_REFUSED: The guest refused this connection.
    ///
    /// Other errors are related to socket creation, see
    /// [zx_socket_create](https://fuchsia.dev/fuchsia-src/reference/syscalls/socket_create.md)
    Connect { guest_port: u32, responder: HostVsockEndpointConnectResponder },
}

impl HostVsockEndpointRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen(
        self,
    ) -> Option<(
        u32,
        fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>,
        HostVsockEndpointListenResponder,
    )> {
        if let HostVsockEndpointRequest::Listen { port, acceptor, responder } = self {
            Some((port, acceptor, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(self) -> Option<(u32, HostVsockEndpointConnectResponder)> {
        if let HostVsockEndpointRequest::Connect { guest_port, responder } = self {
            Some((guest_port, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HostVsockEndpointRequest::Listen { .. } => "listen",
            HostVsockEndpointRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

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

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

impl HostVsockEndpointControlHandle {}

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Socket, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<HostVsockEndpointConnectResponse, i32>>(
                result.map(|socket| (socket,)),
                self.tx_id,
                0x4d12e10e946b43e4,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for LinuxManagerMarker {
    type Proxy = LinuxManagerProxy;
    type RequestStream = LinuxManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LinuxManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.virtualization.LinuxManager";
}
impl fidl::endpoints::DiscoverableProtocolMarker for LinuxManagerMarker {}
pub type LinuxManagerStartAndGetLinuxGuestInfoResult = Result<LinuxGuestInfo, i32>;
pub type LinuxManagerWipeDataResult = Result<(), i32>;

pub trait LinuxManagerProxyInterface: Send + Sync {
    type StartAndGetLinuxGuestInfoResponseFut: std::future::Future<
            Output = Result<LinuxManagerStartAndGetLinuxGuestInfoResult, fidl::Error>,
        > + Send;
    fn r#start_and_get_linux_guest_info(
        &self,
        label: &str,
    ) -> Self::StartAndGetLinuxGuestInfoResponseFut;
    type WipeDataResponseFut: std::future::Future<Output = Result<LinuxManagerWipeDataResult, fidl::Error>>
        + Send;
    fn r#wipe_data(&self) -> Self::WipeDataResponseFut;
    fn r#graceful_shutdown(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LinuxManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LinuxManagerSynchronousProxy {
    type Proxy = LinuxManagerProxy;
    type Protocol = LinuxManagerMarker;

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

    /// Get Linux guest environment info.
    ///
    /// Returns ZX_ERR_UNAVAILABLE if the Linux guest is not available.
    pub fn r#start_and_get_linux_guest_info(
        &self,
        mut label: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LinuxManagerStartAndGetLinuxGuestInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            LinuxManagerStartAndGetLinuxGuestInfoRequest,
            fidl::encoding::ResultType<LinuxManagerStartAndGetLinuxGuestInfoResponse, i32>,
            LinuxManagerMarker,
        >(
            (label,),
            0x11809ced100a2bea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.info))
    }

    /// Clears the stateful data. This includes any installed containers and any user data
    /// they may contain.
    ///
    /// Returns ZX_ERR_BAD_STATE if this is called while the VM is running.
    /// Returns ZX_ERR_IO if there was an IO failure while performing the
    /// operation.
    pub fn r#wipe_data(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LinuxManagerWipeDataResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            LinuxManagerMarker,
        >(
            (),
            0x732c69394548a76a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Attempts to gracefully shut down a running guest. The caller must ensure that the guest
    /// has actually stopped (such as by waiting on a Guest client PEER_CLOSED signal and checking
    /// the epitaph) before attempting to launch another guest.
    ///
    /// On a clean shutdown the Guest client will contain a ZX_OK epitaph, and on an unexpected
    /// shutdown the client will contain a ZX_ERR_INTERNAL epitaph (or no epitaph if there was
    /// a component crash).
    pub fn r#graceful_shutdown(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5dab12b50bc9909d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LinuxManagerProxy {
    type Protocol = LinuxManagerMarker;

    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 LinuxManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/LinuxManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LinuxManagerMarker 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) -> LinuxManagerEventStream {
        LinuxManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get Linux guest environment info.
    ///
    /// Returns ZX_ERR_UNAVAILABLE if the Linux guest is not available.
    pub fn r#start_and_get_linux_guest_info(
        &self,
        mut label: &str,
    ) -> fidl::client::QueryResponseFut<
        LinuxManagerStartAndGetLinuxGuestInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LinuxManagerProxyInterface::r#start_and_get_linux_guest_info(self, label)
    }

    /// Clears the stateful data. This includes any installed containers and any user data
    /// they may contain.
    ///
    /// Returns ZX_ERR_BAD_STATE if this is called while the VM is running.
    /// Returns ZX_ERR_IO if there was an IO failure while performing the
    /// operation.
    pub fn r#wipe_data(
        &self,
    ) -> fidl::client::QueryResponseFut<
        LinuxManagerWipeDataResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LinuxManagerProxyInterface::r#wipe_data(self)
    }

    /// Attempts to gracefully shut down a running guest. The caller must ensure that the guest
    /// has actually stopped (such as by waiting on a Guest client PEER_CLOSED signal and checking
    /// the epitaph) before attempting to launch another guest.
    ///
    /// On a clean shutdown the Guest client will contain a ZX_OK epitaph, and on an unexpected
    /// shutdown the client will contain a ZX_ERR_INTERNAL epitaph (or no epitaph if there was
    /// a component crash).
    pub fn r#graceful_shutdown(&self) -> Result<(), fidl::Error> {
        LinuxManagerProxyInterface::r#graceful_shutdown(self)
    }
}

impl LinuxManagerProxyInterface for LinuxManagerProxy {
    type StartAndGetLinuxGuestInfoResponseFut = fidl::client::QueryResponseFut<
        LinuxManagerStartAndGetLinuxGuestInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_and_get_linux_guest_info(
        &self,
        mut label: &str,
    ) -> Self::StartAndGetLinuxGuestInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LinuxManagerStartAndGetLinuxGuestInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<LinuxManagerStartAndGetLinuxGuestInfoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x11809ced100a2bea,
            >(_buf?)?;
            Ok(_response.map(|x| x.info))
        }
        self.client.send_query_and_decode::<
            LinuxManagerStartAndGetLinuxGuestInfoRequest,
            LinuxManagerStartAndGetLinuxGuestInfoResult,
        >(
            (label,),
            0x11809ced100a2bea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WipeDataResponseFut = fidl::client::QueryResponseFut<
        LinuxManagerWipeDataResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#wipe_data(&self) -> Self::WipeDataResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LinuxManagerWipeDataResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x732c69394548a76a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, LinuxManagerWipeDataResult>(
                (),
                0x732c69394548a76a,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

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

#[derive(Debug)]
pub enum LinuxManagerEvent {
    OnGuestInfoChanged { label: String, info: LinuxGuestInfo },
}

impl LinuxManagerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_guest_info_changed(self) -> Option<(String, LinuxGuestInfo)> {
        if let LinuxManagerEvent::OnGuestInfoChanged { label, info } = self {
            Some((label, info))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::RequestStream for LinuxManagerRequestStream {
    type Protocol = LinuxManagerMarker;
    type ControlHandle = LinuxManagerControlHandle;

    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 {
        LinuxManagerControlHandle { 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 LinuxManagerRequestStream {
    type Item = Result<LinuxManagerRequest, 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 LinuxManagerRequestStream 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 {
                    0x11809ced100a2bea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinuxManagerStartAndGetLinuxGuestInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LinuxManagerStartAndGetLinuxGuestInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LinuxManagerControlHandle { inner: this.inner.clone() };
                        Ok(LinuxManagerRequest::StartAndGetLinuxGuestInfo {
                            label: req.label,

                            responder: LinuxManagerStartAndGetLinuxGuestInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x732c69394548a76a => {
                        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 =
                            LinuxManagerControlHandle { inner: this.inner.clone() };
                        Ok(LinuxManagerRequest::WipeData {
                            responder: LinuxManagerWipeDataResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5dab12b50bc9909d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LinuxManagerControlHandle { inner: this.inner.clone() };
                        Ok(LinuxManagerRequest::GracefulShutdown { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <LinuxManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A `LinuxManager` provides access to the status of Linux guest instances.
#[derive(Debug)]
pub enum LinuxManagerRequest {
    /// Get Linux guest environment info.
    ///
    /// Returns ZX_ERR_UNAVAILABLE if the Linux guest is not available.
    StartAndGetLinuxGuestInfo {
        label: String,
        responder: LinuxManagerStartAndGetLinuxGuestInfoResponder,
    },
    /// Clears the stateful data. This includes any installed containers and any user data
    /// they may contain.
    ///
    /// Returns ZX_ERR_BAD_STATE if this is called while the VM is running.
    /// Returns ZX_ERR_IO if there was an IO failure while performing the
    /// operation.
    WipeData { responder: LinuxManagerWipeDataResponder },
    /// Attempts to gracefully shut down a running guest. The caller must ensure that the guest
    /// has actually stopped (such as by waiting on a Guest client PEER_CLOSED signal and checking
    /// the epitaph) before attempting to launch another guest.
    ///
    /// On a clean shutdown the Guest client will contain a ZX_OK epitaph, and on an unexpected
    /// shutdown the client will contain a ZX_ERR_INTERNAL epitaph (or no epitaph if there was
    /// a component crash).
    GracefulShutdown { control_handle: LinuxManagerControlHandle },
}

impl LinuxManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_and_get_linux_guest_info(
        self,
    ) -> Option<(String, LinuxManagerStartAndGetLinuxGuestInfoResponder)> {
        if let LinuxManagerRequest::StartAndGetLinuxGuestInfo { label, responder } = self {
            Some((label, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wipe_data(self) -> Option<(LinuxManagerWipeDataResponder)> {
        if let LinuxManagerRequest::WipeData { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_graceful_shutdown(self) -> Option<(LinuxManagerControlHandle)> {
        if let LinuxManagerRequest::GracefulShutdown { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LinuxManagerRequest::StartAndGetLinuxGuestInfo { .. } => {
                "start_and_get_linux_guest_info"
            }
            LinuxManagerRequest::WipeData { .. } => "wipe_data",
            LinuxManagerRequest::GracefulShutdown { .. } => "graceful_shutdown",
        }
    }
}

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

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

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

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

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

impl LinuxManagerControlHandle {
    pub fn send_on_guest_info_changed(
        &self,
        mut label: &str,
        mut info: &LinuxGuestInfo,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<LinuxManagerOnGuestInfoChangedRequest>(
            (label, info),
            0,
            0x30a9be4c43d6a2d6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&LinuxGuestInfo, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            LinuxManagerStartAndGetLinuxGuestInfoResponse,
            i32,
        >>(
            result.map(|info| (info,)),
            self.tx_id,
            0x11809ced100a2bea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for MemControllerMarker {
    type Proxy = MemControllerProxy;
    type RequestStream = MemControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MemControllerSynchronousProxy;

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

pub trait MemControllerProxyInterface: Send + Sync {
    type GetMemSizeResponseFut: std::future::Future<Output = Result<(u64, u64, u64, u64, u64), fidl::Error>>
        + Send;
    fn r#get_mem_size(&self) -> Self::GetMemSizeResponseFut;
    fn r#request_size(&self, requested_size: u64) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MemControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MemControllerSynchronousProxy {
    type Proxy = MemControllerProxy;
    type Protocol = MemControllerMarker;

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

    /// Get the configured region size, usable region size, plugged size and requestd size
    ///
    /// block_size is the size and the alignment in bytes of a memory block. Cannot change.
    /// region_size is the size of device-managed memory region in bytes. Cannot change.
    /// usable_region_size is the size of the usable device-managed memory region. Can grow up to
    /// the region_size. Can only shrink due to VIRTIO_MEM_REQ_UNPLUG_ALL requests.
    /// plugged_size is the amount of plugged memory in bytes within the usable device-managed
    /// memory region.
    /// requested_size is the requested amount of plugged memory within the usable device-managed
    /// memory region.
    pub fn r#get_mem_size(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u64, u64, u64, u64, u64), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            MemControllerGetMemSizeResponse,
            MemControllerMarker,
        >(
            (),
            0x6e9d496f9b66ea56,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((
            _response.block_size,
            _response.region_size,
            _response.usable_region_size,
            _response.plugged_size,
            _response.requested_size,
        ))
    }

    /// Update the requested size to plug or unplug memory
    ///
    /// The driver SHOULD react to resize requests from the device (requested_size in the device
    /// configuration changed) by (un)plugging memory blocks.
    pub fn r#request_size(&self, mut requested_size: u64) -> Result<(), fidl::Error> {
        self.client.send::<MemControllerRequestSizeRequest>(
            (requested_size,),
            0x12f8e2cc21ee8102,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for MemControllerProxy {
    type Protocol = MemControllerMarker;

    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 MemControllerProxy {
    /// Create a new Proxy for fuchsia.virtualization/MemController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MemControllerMarker 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) -> MemControllerEventStream {
        MemControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get the configured region size, usable region size, plugged size and requestd size
    ///
    /// block_size is the size and the alignment in bytes of a memory block. Cannot change.
    /// region_size is the size of device-managed memory region in bytes. Cannot change.
    /// usable_region_size is the size of the usable device-managed memory region. Can grow up to
    /// the region_size. Can only shrink due to VIRTIO_MEM_REQ_UNPLUG_ALL requests.
    /// plugged_size is the amount of plugged memory in bytes within the usable device-managed
    /// memory region.
    /// requested_size is the requested amount of plugged memory within the usable device-managed
    /// memory region.
    pub fn r#get_mem_size(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (u64, u64, u64, u64, u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MemControllerProxyInterface::r#get_mem_size(self)
    }

    /// Update the requested size to plug or unplug memory
    ///
    /// The driver SHOULD react to resize requests from the device (requested_size in the device
    /// configuration changed) by (un)plugging memory blocks.
    pub fn r#request_size(&self, mut requested_size: u64) -> Result<(), fidl::Error> {
        MemControllerProxyInterface::r#request_size(self, requested_size)
    }
}

impl MemControllerProxyInterface for MemControllerProxy {
    type GetMemSizeResponseFut = fidl::client::QueryResponseFut<
        (u64, u64, u64, u64, u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mem_size(&self) -> Self::GetMemSizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u64, u64, u64, u64, u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MemControllerGetMemSizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e9d496f9b66ea56,
            >(_buf?)?;
            Ok((
                _response.block_size,
                _response.region_size,
                _response.usable_region_size,
                _response.plugged_size,
                _response.requested_size,
            ))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, (u64, u64, u64, u64, u64)>(
                (),
                0x6e9d496f9b66ea56,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#request_size(&self, mut requested_size: u64) -> Result<(), fidl::Error> {
        self.client.send::<MemControllerRequestSizeRequest>(
            (requested_size,),
            0x12f8e2cc21ee8102,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for MemControllerRequestStream {
    type Protocol = MemControllerMarker;
    type ControlHandle = MemControllerControlHandle;

    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 {
        MemControllerControlHandle { 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 MemControllerRequestStream {
    type Item = Result<MemControllerRequest, 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 MemControllerRequestStream 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 {
                    0x6e9d496f9b66ea56 => {
                        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 =
                            MemControllerControlHandle { inner: this.inner.clone() };
                        Ok(MemControllerRequest::GetMemSize {
                            responder: MemControllerGetMemSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x12f8e2cc21ee8102 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MemControllerRequestSizeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MemControllerRequestSizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            MemControllerControlHandle { inner: this.inner.clone() };
                        Ok(MemControllerRequest::RequestSize {
                            requested_size: req.requested_size,

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

/// A `MemController` controls a guest's virtio-mem
#[derive(Debug)]
pub enum MemControllerRequest {
    /// Get the configured region size, usable region size, plugged size and requestd size
    ///
    /// block_size is the size and the alignment in bytes of a memory block. Cannot change.
    /// region_size is the size of device-managed memory region in bytes. Cannot change.
    /// usable_region_size is the size of the usable device-managed memory region. Can grow up to
    /// the region_size. Can only shrink due to VIRTIO_MEM_REQ_UNPLUG_ALL requests.
    /// plugged_size is the amount of plugged memory in bytes within the usable device-managed
    /// memory region.
    /// requested_size is the requested amount of plugged memory within the usable device-managed
    /// memory region.
    GetMemSize { responder: MemControllerGetMemSizeResponder },
    /// Update the requested size to plug or unplug memory
    ///
    /// The driver SHOULD react to resize requests from the device (requested_size in the device
    /// configuration changed) by (un)plugging memory blocks.
    RequestSize { requested_size: u64, control_handle: MemControllerControlHandle },
}

impl MemControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mem_size(self) -> Option<(MemControllerGetMemSizeResponder)> {
        if let MemControllerRequest::GetMemSize { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_size(self) -> Option<(u64, MemControllerControlHandle)> {
        if let MemControllerRequest::RequestSize { requested_size, control_handle } = self {
            Some((requested_size, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            MemControllerRequest::GetMemSize { .. } => "get_mem_size",
            MemControllerRequest::RequestSize { .. } => "request_size",
        }
    }
}

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

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

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

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

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

impl MemControllerControlHandle {}

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

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

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

    fn send_raw(
        &self,
        mut block_size: u64,
        mut region_size: u64,
        mut usable_region_size: u64,
        mut plugged_size: u64,
        mut requested_size: u64,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MemControllerGetMemSizeResponse>(
            (block_size, region_size, usable_region_size, plugged_size, requested_size),
            self.tx_id,
            0x6e9d496f9b66ea56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for TerminaGuestManagerMarker {
    type Proxy = TerminaGuestManagerProxy;
    type RequestStream = TerminaGuestManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TerminaGuestManagerSynchronousProxy;

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

pub trait TerminaGuestManagerProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<GuestManagerLaunchResult, fidl::Error>>
        + Send;
    fn r#launch(
        &self,
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut;
    type ForceShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#force_shutdown(&self) -> Self::ForceShutdownResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<GuestManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<GuestInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TerminaGuestManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TerminaGuestManagerSynchronousProxy {
    type Proxy = TerminaGuestManagerProxy;
    type Protocol = TerminaGuestManagerMarker;

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

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerLaunchResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerLaunchRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, TerminaGuestManagerMarker>(
                (&mut guest_config, controller),
                0x394a2e29f750323e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            TerminaGuestManagerMarker,
        >(
            (),
            0x3ad9a012982f872d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, TerminaGuestManagerMarker>(
                (controller,),
                0x4e489076e3bb15b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Query guest info
    pub fn r#get_info(&self, ___deadline: zx::MonotonicInstant) -> Result<GuestInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            GuestManagerGetInfoResponse,
            TerminaGuestManagerMarker,
        >(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.guest_info)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TerminaGuestManagerProxy {
    type Protocol = TerminaGuestManagerMarker;

    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 TerminaGuestManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/TerminaGuestManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <TerminaGuestManagerMarker 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) -> TerminaGuestManagerEventStream {
        TerminaGuestManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TerminaGuestManagerProxyInterface::r#launch(self, guest_config, controller)
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        TerminaGuestManagerProxyInterface::r#force_shutdown(self)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TerminaGuestManagerProxyInterface::r#connect(self, controller)
    }

    /// Query guest info
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        TerminaGuestManagerProxyInterface::r#get_info(self)
    }
}

impl TerminaGuestManagerProxyInterface for TerminaGuestManagerProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerLaunchResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x394a2e29f750323e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerLaunchRequest, GuestManagerLaunchResult>(
            (&mut guest_config, controller),
            0x394a2e29f750323e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e489076e3bb15b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerConnectRequest, GuestManagerConnectResult>(
            (controller,),
            0x4e489076e3bb15b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                GuestManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76892614aea695dc,
            >(_buf?)?;
            Ok(_response.guest_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestInfo>(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TerminaGuestManagerRequestStream {
    type Protocol = TerminaGuestManagerMarker;
    type ControlHandle = TerminaGuestManagerControlHandle;

    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 {
        TerminaGuestManagerControlHandle { 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 TerminaGuestManagerRequestStream {
    type Item = Result<TerminaGuestManagerRequest, 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 TerminaGuestManagerRequestStream 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 {
                0x394a2e29f750323e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerLaunchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = TerminaGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TerminaGuestManagerRequest::Launch {guest_config: req.guest_config,
controller: req.controller,

                        responder: TerminaGuestManagerLaunchResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ad9a012982f872d => {
                    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 = TerminaGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TerminaGuestManagerRequest::ForceShutdown {
                        responder: TerminaGuestManagerForceShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4e489076e3bb15b4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = TerminaGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TerminaGuestManagerRequest::Connect {controller: req.controller,

                        responder: TerminaGuestManagerConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76892614aea695dc => {
                    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 = TerminaGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TerminaGuestManagerRequest::GetInfo {
                        responder: TerminaGuestManagerGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <TerminaGuestManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum TerminaGuestManagerRequest {
    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    Launch {
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: TerminaGuestManagerLaunchResponder,
    },
    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    ForceShutdown { responder: TerminaGuestManagerForceShutdownResponder },
    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    Connect {
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: TerminaGuestManagerConnectResponder,
    },
    /// Query guest info
    GetInfo { responder: TerminaGuestManagerGetInfoResponder },
}

impl TerminaGuestManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(
        self,
    ) -> Option<(
        GuestConfig,
        fidl::endpoints::ServerEnd<GuestMarker>,
        TerminaGuestManagerLaunchResponder,
    )> {
        if let TerminaGuestManagerRequest::Launch { guest_config, controller, responder } = self {
            Some((guest_config, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_shutdown(self) -> Option<(TerminaGuestManagerForceShutdownResponder)> {
        if let TerminaGuestManagerRequest::ForceShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, TerminaGuestManagerConnectResponder)>
    {
        if let TerminaGuestManagerRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(TerminaGuestManagerGetInfoResponder)> {
        if let TerminaGuestManagerRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            TerminaGuestManagerRequest::Launch { .. } => "launch",
            TerminaGuestManagerRequest::ForceShutdown { .. } => "force_shutdown",
            TerminaGuestManagerRequest::Connect { .. } => "connect",
            TerminaGuestManagerRequest::GetInfo { .. } => "get_info",
        }
    }
}

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

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

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

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

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

impl TerminaGuestManagerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut guest_info: &GuestInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestManagerGetInfoResponse>(
            (guest_info,),
            self.tx_id,
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ZirconGuestManagerMarker {
    type Proxy = ZirconGuestManagerProxy;
    type RequestStream = ZirconGuestManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ZirconGuestManagerSynchronousProxy;

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

pub trait ZirconGuestManagerProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<GuestManagerLaunchResult, fidl::Error>>
        + Send;
    fn r#launch(
        &self,
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut;
    type ForceShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#force_shutdown(&self) -> Self::ForceShutdownResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<GuestManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<GuestInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ZirconGuestManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ZirconGuestManagerSynchronousProxy {
    type Proxy = ZirconGuestManagerProxy;
    type Protocol = ZirconGuestManagerMarker;

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

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerLaunchResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerLaunchRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, ZirconGuestManagerMarker>(
                (&mut guest_config, controller),
                0x394a2e29f750323e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            ZirconGuestManagerMarker,
        >(
            (),
            0x3ad9a012982f872d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GuestManagerConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<GuestManagerConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GuestManagerError,
            >, ZirconGuestManagerMarker>(
                (controller,),
                0x4e489076e3bb15b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Query guest info
    pub fn r#get_info(&self, ___deadline: zx::MonotonicInstant) -> Result<GuestInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            GuestManagerGetInfoResponse,
            ZirconGuestManagerMarker,
        >(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.guest_info)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ZirconGuestManagerProxy {
    type Protocol = ZirconGuestManagerMarker;

    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 ZirconGuestManagerProxy {
    /// Create a new Proxy for fuchsia.virtualization/ZirconGuestManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ZirconGuestManagerMarker 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) -> ZirconGuestManagerEventStream {
        ZirconGuestManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    pub fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ZirconGuestManagerProxyInterface::r#launch(self, guest_config, controller)
    }

    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    pub fn r#force_shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ZirconGuestManagerProxyInterface::r#force_shutdown(self)
    }

    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    pub fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ZirconGuestManagerProxyInterface::r#connect(self, controller)
    }

    /// Query guest info
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ZirconGuestManagerProxyInterface::r#get_info(self)
    }
}

impl ZirconGuestManagerProxyInterface for ZirconGuestManagerProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        GuestManagerLaunchResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#launch(
        &self,
        mut guest_config: GuestConfig,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerLaunchResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x394a2e29f750323e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerLaunchRequest, GuestManagerLaunchResult>(
            (&mut guest_config, controller),
            0x394a2e29f750323e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        GuestManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<GuestMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GuestManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e489076e3bb15b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GuestManagerConnectRequest, GuestManagerConnectResult>(
            (controller,),
            0x4e489076e3bb15b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<GuestInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GuestInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                GuestManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76892614aea695dc,
            >(_buf?)?;
            Ok(_response.guest_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GuestInfo>(
            (),
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ZirconGuestManagerRequestStream {
    type Protocol = ZirconGuestManagerMarker;
    type ControlHandle = ZirconGuestManagerControlHandle;

    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 {
        ZirconGuestManagerControlHandle { 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 ZirconGuestManagerRequestStream {
    type Item = Result<ZirconGuestManagerRequest, 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 ZirconGuestManagerRequestStream 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 {
                0x394a2e29f750323e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerLaunchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ZirconGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ZirconGuestManagerRequest::Launch {guest_config: req.guest_config,
controller: req.controller,

                        responder: ZirconGuestManagerLaunchResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ad9a012982f872d => {
                    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 = ZirconGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ZirconGuestManagerRequest::ForceShutdown {
                        responder: ZirconGuestManagerForceShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4e489076e3bb15b4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GuestManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GuestManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ZirconGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ZirconGuestManagerRequest::Connect {controller: req.controller,

                        responder: ZirconGuestManagerConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76892614aea695dc => {
                    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 = ZirconGuestManagerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ZirconGuestManagerRequest::GetInfo {
                        responder: ZirconGuestManagerGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ZirconGuestManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ZirconGuestManagerRequest {
    /// Launch a new guest instance.
    ///
    /// Possible errors:
    ///     - BAD_CONFIG: Failed to parse the config from the guest package, or other config
    ///         problems detected by the guest manager.
    ///     - ALREADY_RUNNING: The guest is already running. Stop the guest before launching again.
    ///     - START_FAILURE: Failed to initialize the VMM and devices, and start the guest. See
    ///         component logs for a more specific failure.
    Launch {
        guest_config: GuestConfig,
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: ZirconGuestManagerLaunchResponder,
    },
    /// Forcibly shuts down a running guest. Immediately after ForceShutdown returns, Launch can
    /// be used to launch another guest.
    ForceShutdown { responder: ZirconGuestManagerForceShutdownResponder },
    /// Connect to a currently running guest.
    ///
    /// Possible errors:
    ///     - NOT_RUNNING: Attempted to connect to a guest in a non-running state. Ensure the guest
    ///         has launched before attempting to reconnect.
    Connect {
        controller: fidl::endpoints::ServerEnd<GuestMarker>,
        responder: ZirconGuestManagerConnectResponder,
    },
    /// Query guest info
    GetInfo { responder: ZirconGuestManagerGetInfoResponder },
}

impl ZirconGuestManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(
        self,
    ) -> Option<(
        GuestConfig,
        fidl::endpoints::ServerEnd<GuestMarker>,
        ZirconGuestManagerLaunchResponder,
    )> {
        if let ZirconGuestManagerRequest::Launch { guest_config, controller, responder } = self {
            Some((guest_config, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_shutdown(self) -> Option<(ZirconGuestManagerForceShutdownResponder)> {
        if let ZirconGuestManagerRequest::ForceShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<GuestMarker>, ZirconGuestManagerConnectResponder)> {
        if let ZirconGuestManagerRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(ZirconGuestManagerGetInfoResponder)> {
        if let ZirconGuestManagerRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ZirconGuestManagerRequest::Launch { .. } => "launch",
            ZirconGuestManagerRequest::ForceShutdown { .. } => "force_shutdown",
            ZirconGuestManagerRequest::Connect { .. } => "connect",
            ZirconGuestManagerRequest::GetInfo { .. } => "get_info",
        }
    }
}

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

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

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

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

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

impl ZirconGuestManagerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut guest_info: &GuestInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<GuestManagerGetInfoResponse>(
            (guest_info,),
            self.tx_id,
            0x76892614aea695dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for BlockSpec {
        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 BlockSpec {
        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<BlockSpec, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut BlockSpec
    {
        #[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::<BlockSpec>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlockSpec, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<20> as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <BlockMode as fidl::encoding::ValueTypeMarker>::borrow(&self.mode),
                    <BlockFormat as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.format),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<20>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<BlockMode, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<BlockFormat, fidl::encoding::DefaultFuchsiaResourceDialect>,
    > fidl::encoding::Encode<BlockSpec, 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::<BlockSpec>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for BlockSpec {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl::encoding::BoundedString<20>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mode: fidl::new_empty!(BlockMode, fidl::encoding::DefaultFuchsiaResourceDialect),
                format: fidl::new_empty!(
                    BlockFormat,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            GuestGetSerialResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GuestGetSerialResponse
    {
        #[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::<GuestGetSerialResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GuestGetSerialResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<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<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GuestGetSerialResponse,
            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::<GuestGetSerialResponse>(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 GuestGetSerialResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                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.
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            GuestManagerLaunchRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GuestManagerLaunchRequest
    {
        #[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::<GuestManagerLaunchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<GuestManagerLaunchRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <GuestConfig as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.guest_config),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GuestMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<GuestConfig, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GuestMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GuestManagerLaunchRequest,
            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::<GuestManagerLaunchRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for GuestManagerLaunchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                guest_config: fidl::new_empty!(
                    GuestConfig,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GuestMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            GuestGetConsoleResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GuestGetConsoleResponse
    {
        #[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::<GuestGetConsoleResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GuestGetConsoleResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<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<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GuestGetConsoleResponse,
            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::<GuestGetConsoleResponse>(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 GuestGetConsoleResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                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.
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            HostVsockAcceptorAcceptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut HostVsockAcceptorAcceptResponse
    {
        #[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::<HostVsockAcceptorAcceptResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                HostVsockAcceptorAcceptResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<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<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            HostVsockAcceptorAcceptResponse,
            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::<HostVsockAcceptorAcceptResponse>(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 HostVsockAcceptorAcceptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                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.
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            HostVsockEndpointConnectResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut HostVsockEndpointConnectResponse
    {
        #[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::<HostVsockEndpointConnectResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                HostVsockEndpointConnectResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<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<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            HostVsockEndpointConnectResponse,
            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::<HostVsockEndpointConnectResponse>(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 HostVsockEndpointConnectResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                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.
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl fidl::encoding::Encode<Listener, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Listener
    {
        #[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::<Listener>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Listener, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.port),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.acceptor),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<Listener, 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::<Listener>(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 + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Listener {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                port: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                acceptor: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>>,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.port,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HostVsockAcceptorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.acceptor,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl GuestConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.virtio_mem_region_alignment {
                return 25;
            }
            if let Some(_) = self.virtio_mem_region_size {
                return 24;
            }
            if let Some(_) = self.virtio_mem_block_size {
                return 23;
            }
            if let Some(_) = self.virtio_mem {
                return 22;
            }
            if let Some(_) = self.vsock_listeners {
                return 21;
            }
            if let Some(_) = self.virtio_sound_input {
                return 20;
            }
            if let Some(_) = self.virtio_sound {
                return 19;
            }
            if let Some(_) = self.virtio_vsock {
                return 18;
            }
            if let Some(_) = self.virtio_rng {
                return 17;
            }
            if let Some(_) = self.virtio_gpu {
                return 16;
            }
            if let Some(_) = self.virtio_console {
                return 15;
            }
            if let Some(_) = self.virtio_balloon {
                return 14;
            }
            if let Some(_) = self.default_net {
                return 13;
            }
            if let Some(_) = self.net_devices {
                return 10;
            }
            if let Some(_) = self.block_devices {
                return 9;
            }
            if let Some(_) = self.guest_memory {
                return 8;
            }
            if let Some(_) = self.cpus {
                return 7;
            }
            if let Some(_) = self.cmdline_add {
                return 6;
            }
            if let Some(_) = self.cmdline {
                return 5;
            }
            if let Some(_) = self.dtb_overlay {
                return 4;
            }
            if let Some(_) = self.ramdisk {
                return 3;
            }
            if let Some(_) = self.kernel {
                return 2;
            }
            if let Some(_) = self.kernel_type {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for BlockFormat {
        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 BlockFormat {
        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<BlockFormat, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut BlockFormat
    {
        #[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::<BlockFormat>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                BlockFormat::File(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                BlockFormat::Qcow(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                BlockFormat::Block(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for BlockFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::File(fidl::new_empty!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
                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::ClientEnd<fidl_fuchsia_io::FileMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>,
                > 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 BlockFormat::File(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = BlockFormat::File(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let BlockFormat::File(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let BlockFormat::Qcow(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = BlockFormat::Qcow(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let BlockFormat::Qcow(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let BlockFormat::Block(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = BlockFormat::Block(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let BlockFormat::Block(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<fidl_fuchsia_storage_block::BlockMarker>,
                            >,
                            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(())
        }
    }
}