fdomain_fuchsia_hardware_network/

fdomain_fuchsia_hardware_network.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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_hardware_network_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceCloneRequest {
    pub device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DeviceCloneRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceGetPortRequest {
    pub id: PortId,
    pub port: fdomain_client::fidl::ServerEnd<PortMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DeviceGetPortRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceGetPortWatcherRequest {
    pub watcher: fdomain_client::fidl::ServerEnd<PortWatcherMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for DeviceGetPortWatcherRequest
{
}

#[derive(Debug, PartialEq)]
pub struct DeviceOpenSessionRequest {
    pub session_name: String,
    pub session_info: SessionInfo,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DeviceOpenSessionRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceOpenSessionResponse {
    pub session: fdomain_client::fidl::ClientEnd<SessionMarker>,
    pub fifos: Fifos,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DeviceOpenSessionResponse {}

/// Data-plane FIFOs.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Fifos {
    /// Handle for the rx FIFO.
    ///
    /// Clients must write 16-bit descriptor indexes to this FIFO to be able to
    /// receive frames.
    pub rx: fdomain_client::Fifo,
    /// Handle for the tx FIFO.
    ///
    /// Clients write 16-bit descriptor indexes to this FIFO to enqueue outgoing
    /// frames.
    pub tx: fdomain_client::Fifo,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for Fifos {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortCloneRequest {
    pub port: fdomain_client::fidl::ServerEnd<PortMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for PortCloneRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetDeviceRequest {
    pub device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for PortGetDeviceRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetDiagnosticsRequest {
    pub diagnostics: fdomain_client::fidl::ServerEnd<DiagnosticsMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for PortGetDiagnosticsRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetIdentityResponse {
    pub event: fdomain_client::Event,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for PortGetIdentityResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetMacRequest {
    pub mac: fdomain_client::fidl::ServerEnd<MacAddressingMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for PortGetMacRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetPowerDependencyTokenResponse {
    pub token: Option<fdomain_client::Event>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for PortGetPowerDependencyTokenResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PortGetStatusWatcherRequest {
    pub watcher: fdomain_client::fidl::ServerEnd<StatusWatcherMarker>,
    pub buffer: u32,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for PortGetStatusWatcherRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionRegisterForTxRequest {
    pub vmos: Vec<u8>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for SessionRegisterForTxRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionUnregisterForTxRequest {
    pub vmos: Vec<u8>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for SessionUnregisterForTxRequest
{
}

#[derive(Debug, PartialEq)]
pub struct SessionWatchDelegatedRxLeaseResponse {
    pub lease: DelegatedRxLease,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for SessionWatchDelegatedRxLeaseResponse
{
}

/// A VMO that can be used for data-plane operations.
#[derive(Debug, Default, PartialEq)]
pub struct DataVmo {
    pub id: Option<u8>,
    pub vmo: Option<fdomain_client::Vmo>,
    /// Netdevice needs this information to decide when to safely unregister and
    /// decommit.
    pub num_rx_buffers: Option<u16>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DataVmo {}

/// An acquired lease that is propagated up to applications.
#[derive(Debug, Default, PartialEq)]
pub struct DelegatedRxLease {
    /// The frame after which the lease in `handle` can be released.
    ///
    /// Agents observing leases must keep track of received frames with an
    /// increasing counter to be able to properly relinquish leases after the
    /// frame `hold_until_frame` is fully processed.
    ///
    /// This value can be interpreted as either the 1-based index of a given
    /// frame or as the total number of exchanged frames so far, which are
    /// mathematically equivalent.
    ///
    /// This mechanism allows for wake lease handles from received frames to be
    /// passed up and keep the system from suspension until the frame is fully
    /// processed.
    ///
    /// Required.
    pub hold_until_frame: Option<u64>,
    /// A handle representing the held lease.
    ///
    /// Required.
    pub handle: Option<DelegatedRxLeaseHandle>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DelegatedRxLease {}

/// Session configuration.
#[derive(Debug, Default, PartialEq)]
pub struct SessionInfo {
    /// VMO containing the descriptors. Required.
    ///
    /// 16-bit indices transmitted over the FIFOs index a descriptor in this VMO
    /// (byte offset = descriptor_length * 8 * index).
    pub descriptors: Option<fdomain_client::Vmo>,
    /// VMOs containing frame data. Required.
    ///
    /// Descriptors contain byte-offsets and vmo ids that are used to index regions
    /// in data VMOs.
    ///
    /// For Rx VMOs managed by the device interface, VMOs are committed in ID order.
    pub data: Option<Vec<DataVmo>>,
    /// Requested descriptor version. Required.
    ///
    /// If the network device does not support the requested descriptor version,
    /// [`Device.OpenSession`] fails with `ZX_ERR_NOT_SUPPORTED`.
    pub descriptor_version: Option<u8>,
    /// Descriptor length, in 64-bit words. Required.
    ///
    /// The length of each descriptor in the `descriptors` VMO. This is used as
    /// a multiplier to find byte offsets in `descriptors` given a descriptor
    /// index passed through the rx or tx FIFOs.
    pub descriptor_length: Option<u8>,
    /// Total number of descriptors that can be used by this session. Required.
    ///
    /// Descriptor indices transferred through either the rx or tx FIFO must be
    /// in the range [0, `descriptor_count`).
    pub descriptor_count: Option<u16>,
    /// Extra options. Interpreted as empty bitmask if absent.
    pub options: Option<SessionFlags>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for SessionInfo {}

#[derive(Debug)]
pub enum DelegatedRxLeaseHandle {
    /// An untyped channel representing a lease.
    ///
    /// Close the channel to release the lease.
    Channel(fdomain_client::Channel),
    /// An eventpair representing a lease.
    ///
    /// Close the eventpair to release the lease.
    Eventpair(fdomain_client::EventPair),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `DelegatedRxLeaseHandle` member.
#[macro_export]
macro_rules! DelegatedRxLeaseHandleUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for DelegatedRxLeaseHandle {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Channel(x), Self::Channel(y)) => *x == *y,
            (Self::Eventpair(x), Self::Eventpair(y)) => *x == *y,
            _ => false,
        }
    }
}

impl DelegatedRxLeaseHandle {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Channel(_) => 1,
            Self::Eventpair(_) => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for DelegatedRxLeaseHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for DeviceMarker {
    type Proxy = DeviceProxy;
    type RequestStream = DeviceRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Device";
}
pub type DeviceOpenSessionResult =
    Result<(fdomain_client::fidl::ClientEnd<SessionMarker>, Fifos), i32>;

pub trait DeviceProxyInterface: Send + Sync {
    type GetInfoResponseFut: std::future::Future<Output = Result<DeviceInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type OpenSessionResponseFut: std::future::Future<Output = Result<DeviceOpenSessionResult, fidl::Error>>
        + Send;
    fn r#open_session(
        &self,
        session_name: &str,
        session_info: SessionInfo,
    ) -> Self::OpenSessionResponseFut;
    fn r#get_port(
        &self,
        id: &PortId,
        port: fdomain_client::fidl::ServerEnd<PortMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_port_watcher(
        &self,
        watcher: fdomain_client::fidl::ServerEnd<PortWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#clone(
        &self,
        device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct DeviceProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for DeviceProxy {
    type Protocol = DeviceMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl DeviceProxy {
    /// Create a new Proxy for fuchsia.hardware.network/Device.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <DeviceMarker as fdomain_client::fidl::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) -> DeviceEventStream {
        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Obtain information about device
    ///
    /// - response `info` device information.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<DeviceInfo, fdomain_client::fidl::FDomainResourceDialect>
    {
        DeviceProxyInterface::r#get_info(self)
    }

    /// Opens a new session with the network device.
    ///
    /// + request `session_name` is used as a debugging label attached to this
    /// session.
    /// + request `session_info` contains the necessary information to setup the
    /// session's data exchange.
    /// - response `session` a handle to control the session.
    /// - response `fifos` data-plane FIFOs attached to the session.
    /// * error `ZX_ERR_NOT_SUPPORTED` if `session_info` contains not supported
    /// frame types or descriptors set up.
    /// * error `ZX_ERR_INVALID_ARGS` if `session_info` is missing fields or
    /// contains invalid information.
    /// * error `ZX_ERR_INTERNAL` if the data VMO is rejected by the underlying
    /// device.
    pub fn r#open_session(
        &self,
        mut session_name: &str,
        mut session_info: SessionInfo,
    ) -> fidl::client::QueryResponseFut<
        DeviceOpenSessionResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DeviceProxyInterface::r#open_session(self, session_name, session_info)
    }

    /// Connects to a port the given `id`.
    ///
    /// + request `id` port to connect to.
    /// + request `port` server end of port channel.
    ///
    /// `port` is closed with a `ZX_ERR_NOT_FOUND` epitaph if no port with `id`
    /// exists.
    pub fn r#get_port(
        &self,
        mut id: &PortId,
        mut port: fdomain_client::fidl::ServerEnd<PortMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#get_port(self, id, port)
    }

    /// Connects a [`PortWatcher`] to this device.
    ///
    /// + request `watcher` server end of watcher channel.
    pub fn r#get_port_watcher(
        &self,
        mut watcher: fdomain_client::fidl::ServerEnd<PortWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#get_port_watcher(self, watcher)
    }

    /// Establishes a new connection to this device.
    ///
    /// + request `device` the server end for the new connection.
    pub fn r#clone(
        &self,
        mut device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#clone(self, device)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<DeviceInfo, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetInfoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3c500ca9341e8f56,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceInfo>(
            (),
            0x3c500ca9341e8f56,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OpenSessionResponseFut = fidl::client::QueryResponseFut<
        DeviceOpenSessionResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_session(
        &self,
        mut session_name: &str,
        mut session_info: SessionInfo,
    ) -> Self::OpenSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceOpenSessionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceOpenSessionResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x25940b82146dcf67,
            >(_buf?)?;
            Ok(_response.map(|x| (x.session, x.fifos)))
        }
        self.client.send_query_and_decode::<DeviceOpenSessionRequest, DeviceOpenSessionResult>(
            (session_name, &mut session_info),
            0x25940b82146dcf67,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#get_port(
        &self,
        mut id: &PortId,
        mut port: fdomain_client::fidl::ServerEnd<PortMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceGetPortRequest>(
            (id, port),
            0x340a852c955ba2a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_port_watcher(
        &self,
        mut watcher: fdomain_client::fidl::ServerEnd<PortWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceGetPortWatcherRequest>(
            (watcher,),
            0x104f43c937c39f0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#clone(
        &self,
        mut device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceCloneRequest>(
            (device,),
            0x5882ea09b3809af4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DeviceEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/Device.
pub struct DeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for DeviceRequestStream {
    type Protocol = DeviceMarker;
    type ControlHandle = DeviceControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DeviceControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DeviceRequestStream {
    type Item = Result<DeviceRequest, 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 DeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x3c500ca9341e8f56 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetInfo {
                            responder: DeviceGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25940b82146dcf67 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceOpenSessionRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DeviceOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::OpenSession {
                            session_name: req.session_name,
                            session_info: req.session_info,

                            responder: DeviceOpenSessionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x340a852c955ba2a6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetPortRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DeviceGetPortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetPort { id: req.id, port: req.port, control_handle })
                    }
                    0x104f43c937c39f0c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetPortWatcherRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DeviceGetPortWatcherRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetPortWatcher { watcher: req.watcher, control_handle })
                    }
                    0x5882ea09b3809af4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DeviceCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Clone { device: req.device, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A Network Device.
#[derive(Debug)]
pub enum DeviceRequest {
    /// Obtain information about device
    ///
    /// - response `info` device information.
    GetInfo { responder: DeviceGetInfoResponder },
    /// Opens a new session with the network device.
    ///
    /// + request `session_name` is used as a debugging label attached to this
    /// session.
    /// + request `session_info` contains the necessary information to setup the
    /// session's data exchange.
    /// - response `session` a handle to control the session.
    /// - response `fifos` data-plane FIFOs attached to the session.
    /// * error `ZX_ERR_NOT_SUPPORTED` if `session_info` contains not supported
    /// frame types or descriptors set up.
    /// * error `ZX_ERR_INVALID_ARGS` if `session_info` is missing fields or
    /// contains invalid information.
    /// * error `ZX_ERR_INTERNAL` if the data VMO is rejected by the underlying
    /// device.
    OpenSession {
        session_name: String,
        session_info: SessionInfo,
        responder: DeviceOpenSessionResponder,
    },
    /// Connects to a port the given `id`.
    ///
    /// + request `id` port to connect to.
    /// + request `port` server end of port channel.
    ///
    /// `port` is closed with a `ZX_ERR_NOT_FOUND` epitaph if no port with `id`
    /// exists.
    GetPort {
        id: PortId,
        port: fdomain_client::fidl::ServerEnd<PortMarker>,
        control_handle: DeviceControlHandle,
    },
    /// Connects a [`PortWatcher`] to this device.
    ///
    /// + request `watcher` server end of watcher channel.
    GetPortWatcher {
        watcher: fdomain_client::fidl::ServerEnd<PortWatcherMarker>,
        control_handle: DeviceControlHandle,
    },
    /// Establishes a new connection to this device.
    ///
    /// + request `device` the server end for the new connection.
    Clone {
        device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
        control_handle: DeviceControlHandle,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session(self) -> Option<(String, SessionInfo, DeviceOpenSessionResponder)> {
        if let DeviceRequest::OpenSession { session_name, session_info, responder } = self {
            Some((session_name, session_info, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_port(
        self,
    ) -> Option<(PortId, fdomain_client::fidl::ServerEnd<PortMarker>, DeviceControlHandle)> {
        if let DeviceRequest::GetPort { id, port, control_handle } = self {
            Some((id, port, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_port_watcher(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<PortWatcherMarker>, DeviceControlHandle)> {
        if let DeviceRequest::GetPortWatcher { watcher, control_handle } = self {
            Some((watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<DeviceMarker>, DeviceControlHandle)> {
        if let DeviceRequest::Clone { device, control_handle } = self {
            Some((device, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::GetInfo { .. } => "get_info",
            DeviceRequest::OpenSession { .. } => "open_session",
            DeviceRequest::GetPort { .. } => "get_port",
            DeviceRequest::GetPortWatcher { .. } => "get_port_watcher",
            DeviceRequest::Clone { .. } => "clone",
        }
    }
}

#[derive(Debug, Clone)]
pub struct DeviceControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for DeviceControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl DeviceControlHandle {}

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

/// Set the the channel to be shutdown (see [`DeviceControlHandle::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 DeviceGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DeviceGetInfoResponder {
    type ControlHandle = DeviceControlHandle;

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

    fn send_raw(&self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetInfoResponse>(
            (info,),
            self.tx_id,
            0x3c500ca9341e8f56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`DeviceControlHandle::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 DeviceOpenSessionResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DeviceOpenSessionResponder {
    type ControlHandle = DeviceControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<(fdomain_client::fidl::ClientEnd<SessionMarker>, Fifos), i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<DeviceOpenSessionResponse, i32>>(
            result.as_mut().map_err(|e| *e).map(|(session, fifos)| (std::mem::replace(session, <<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::Handle as fidl::encoding::HandleFor<fdomain_client::fidl::FDomainResourceDialect>>::invalid().into()), fifos,)),
            self.tx_id,
            0x25940b82146dcf67,
            fidl::encoding::DynamicFlags::empty()
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for DiagnosticsMarker {
    type Proxy = DiagnosticsProxy;
    type RequestStream = DiagnosticsRequestStream;

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

pub trait DiagnosticsProxyInterface: Send + Sync {
    type LogDebugInfoToSyslogResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#log_debug_info_to_syslog(&self) -> Self::LogDebugInfoToSyslogResponseFut;
}

#[derive(Debug, Clone)]
pub struct DiagnosticsProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for DiagnosticsProxy {
    type Protocol = DiagnosticsMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl DiagnosticsProxy {
    /// Create a new Proxy for fuchsia.hardware.network/Diagnostics.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <DiagnosticsMarker as fdomain_client::fidl::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) -> DiagnosticsEventStream {
        DiagnosticsEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Requests that the device produces debugging information in the system
    /// logs.
    ///
    /// The call returns once device debug information has been produced.
    pub fn r#log_debug_info_to_syslog(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        DiagnosticsProxyInterface::r#log_debug_info_to_syslog(self)
    }
}

impl DiagnosticsProxyInterface for DiagnosticsProxy {
    type LogDebugInfoToSyslogResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#log_debug_info_to_syslog(&self) -> Self::LogDebugInfoToSyslogResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4222897dfe1f4b4a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4222897dfe1f4b4a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct DiagnosticsEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/Diagnostics.
pub struct DiagnosticsRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for DiagnosticsRequestStream {
    type Protocol = DiagnosticsMarker;
    type ControlHandle = DiagnosticsControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DiagnosticsControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DiagnosticsRequestStream {
    type Item = Result<DiagnosticsRequest, 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 DiagnosticsRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x4222897dfe1f4b4a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DiagnosticsControlHandle { inner: this.inner.clone() };
                        Ok(DiagnosticsRequest::LogDebugInfoToSyslog {
                            responder: DiagnosticsLogDebugInfoToSyslogResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DiagnosticsMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides two way communications between device and upper layers to exchange
/// device health information.
#[derive(Debug)]
pub enum DiagnosticsRequest {
    /// Requests that the device produces debugging information in the system
    /// logs.
    ///
    /// The call returns once device debug information has been produced.
    LogDebugInfoToSyslog { responder: DiagnosticsLogDebugInfoToSyslogResponder },
}

impl DiagnosticsRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_log_debug_info_to_syslog(
        self,
    ) -> Option<(DiagnosticsLogDebugInfoToSyslogResponder)> {
        if let DiagnosticsRequest::LogDebugInfoToSyslog { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

#[derive(Debug, Clone)]
pub struct DiagnosticsControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for DiagnosticsControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl DiagnosticsControlHandle {}

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

/// Set the the channel to be shutdown (see [`DiagnosticsControlHandle::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 DiagnosticsLogDebugInfoToSyslogResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DiagnosticsLogDebugInfoToSyslogResponder {
    type ControlHandle = DiagnosticsControlHandle;

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

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

impl fdomain_client::fidl::ProtocolMarker for MacAddressingMarker {
    type Proxy = MacAddressingProxy;
    type RequestStream = MacAddressingRequestStream;

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

pub trait MacAddressingProxyInterface: Send + Sync {
    type GetUnicastAddressResponseFut: std::future::Future<Output = Result<fdomain_fuchsia_net::MacAddress, fidl::Error>>
        + Send;
    fn r#get_unicast_address(&self) -> Self::GetUnicastAddressResponseFut;
    type SetModeResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_mode(&self, mode: MacFilterMode) -> Self::SetModeResponseFut;
    type AddMulticastAddressResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#add_multicast_address(
        &self,
        address: &fdomain_fuchsia_net::MacAddress,
    ) -> Self::AddMulticastAddressResponseFut;
    type RemoveMulticastAddressResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#remove_multicast_address(
        &self,
        address: &fdomain_fuchsia_net::MacAddress,
    ) -> Self::RemoveMulticastAddressResponseFut;
}

#[derive(Debug, Clone)]
pub struct MacAddressingProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for MacAddressingProxy {
    type Protocol = MacAddressingMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl MacAddressingProxy {
    /// Create a new Proxy for fuchsia.hardware.network/MacAddressing.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <MacAddressingMarker as fdomain_client::fidl::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) -> MacAddressingEventStream {
        MacAddressingEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the Device's current unicast MAC address.
    ///
    /// Implementers of this API do not need to return a uniquely identifiable
    /// MAC; the unicast address returned is the one that is *currently* in use
    /// to filter unicast frames, or that identifies the device on a link it's
    /// *currently* on. Users of this API must not rely on the stability or
    /// uniqueness of the returned value to identify or disambiguate device
    /// instances.
    ///
    /// - response `address` device's unicast MAC address.
    pub fn r#get_unicast_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_fuchsia_net::MacAddress,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        MacAddressingProxyInterface::r#get_unicast_address(self)
    }

    /// Sets requested operating mode of this device to `mode`.
    ///
    /// The requested mode is attached to the current client connection to the
    /// device. Because multiple clients can be attached to the same device at
    /// once, the mode with the least restrictions is the one actively put into
    /// effect into the underlying device implementation.
    ///
    /// If the device does not support the requested mode, but supports a mode
    /// that is more open than the requested one, `SetMode` succeeds regardless.
    /// Otherwise, if the device only supports *more restrictive* modes than the
    /// one requested, `SetMode` returns `ZX_ERR_NOT_SUPPORTED`.
    ///
    /// Clients must be aware that the resource being accessed is shared, and
    /// that the device may be effectively operating at a more open level than
    /// the one that was requested (although never at one more restrictive).
    ///
    /// + request `mode` request mode to attach to.
    /// - response `status` `ZX_ERR_NOT_SUPPORTED` it the device only supports
    /// mode more restrictive than the one requested.
    pub fn r#set_mode(
        &self,
        mut mode: MacFilterMode,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        MacAddressingProxyInterface::r#set_mode(self, mode)
    }

    /// Adds multicast address to the list of multicast groups.
    ///
    /// The list of multicast addresses kept is untouched by calls to `SetMode`.
    /// If the device's mode is not `MULTICAST_FILTER`, the list of multicast
    /// addresses is ignored.
    ///
    /// + request `address` multicast address to add to the list.
    /// - response `status` `ZX_ERR_INVALID_ARGS` if `address` is not a
    /// multicast address.
    /// - response `status` `ZX_ERR_NO_RESOURCES` if there are more than
    /// `MAX_MAC_FILTER` addresses installed.
    pub fn r#add_multicast_address(
        &self,
        mut address: &fdomain_fuchsia_net::MacAddress,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        MacAddressingProxyInterface::r#add_multicast_address(self, address)
    }

    /// Removes multicast address from the list of multicast groups.
    ///
    /// + request `address` multicast address to remove from the list.
    /// - response `status` `ZX_ERR_INVALID_ARGS` if `address` is not a
    /// multicast address.
    pub fn r#remove_multicast_address(
        &self,
        mut address: &fdomain_fuchsia_net::MacAddress,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        MacAddressingProxyInterface::r#remove_multicast_address(self, address)
    }
}

impl MacAddressingProxyInterface for MacAddressingProxy {
    type GetUnicastAddressResponseFut = fidl::client::QueryResponseFut<
        fdomain_fuchsia_net::MacAddress,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_unicast_address(&self) -> Self::GetUnicastAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_fuchsia_net::MacAddress, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MacAddressingGetUnicastAddressResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c60b82a4ecfaebe,
            >(_buf?)?;
            Ok(_response.address)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_fuchsia_net::MacAddress>(
                (),
                0x2c60b82a4ecfaebe,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetModeResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#set_mode(&self, mut mode: MacFilterMode) -> Self::SetModeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MacAddressingSetModeResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6297b8dbf03c58c,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<MacAddressingSetModeRequest, i32>(
            (mode,),
            0x6297b8dbf03c58c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddMulticastAddressResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#add_multicast_address(
        &self,
        mut address: &fdomain_fuchsia_net::MacAddress,
    ) -> Self::AddMulticastAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MacAddressingAddMulticastAddressResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0xf5637ff11cf0c25,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<MacAddressingAddMulticastAddressRequest, i32>(
            (address,),
            0xf5637ff11cf0c25,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveMulticastAddressResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#remove_multicast_address(
        &self,
        mut address: &fdomain_fuchsia_net::MacAddress,
    ) -> Self::RemoveMulticastAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MacAddressingRemoveMulticastAddressResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5dddf4e3ba4e2560,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<MacAddressingRemoveMulticastAddressRequest, i32>(
            (address,),
            0x5dddf4e3ba4e2560,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct MacAddressingEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/MacAddressing.
pub struct MacAddressingRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for MacAddressingRequestStream {
    type Protocol = MacAddressingMarker;
    type ControlHandle = MacAddressingControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        MacAddressingControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for MacAddressingRequestStream {
    type Item = Result<MacAddressingRequest, 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 MacAddressingRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                0x2c60b82a4ecfaebe => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = MacAddressingControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(MacAddressingRequest::GetUnicastAddress {
                        responder: MacAddressingGetUnicastAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6297b8dbf03c58c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(MacAddressingSetModeRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MacAddressingSetModeRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = MacAddressingControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(MacAddressingRequest::SetMode {mode: req.mode,

                        responder: MacAddressingSetModeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xf5637ff11cf0c25 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(MacAddressingAddMulticastAddressRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MacAddressingAddMulticastAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = MacAddressingControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(MacAddressingRequest::AddMulticastAddress {address: req.address,

                        responder: MacAddressingAddMulticastAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5dddf4e3ba4e2560 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(MacAddressingRemoveMulticastAddressRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MacAddressingRemoveMulticastAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = MacAddressingControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(MacAddressingRequest::RemoveMulticastAddress {address: req.address,

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

#[derive(Debug)]
pub enum MacAddressingRequest {
    /// Gets the Device's current unicast MAC address.
    ///
    /// Implementers of this API do not need to return a uniquely identifiable
    /// MAC; the unicast address returned is the one that is *currently* in use
    /// to filter unicast frames, or that identifies the device on a link it's
    /// *currently* on. Users of this API must not rely on the stability or
    /// uniqueness of the returned value to identify or disambiguate device
    /// instances.
    ///
    /// - response `address` device's unicast MAC address.
    GetUnicastAddress { responder: MacAddressingGetUnicastAddressResponder },
    /// Sets requested operating mode of this device to `mode`.
    ///
    /// The requested mode is attached to the current client connection to the
    /// device. Because multiple clients can be attached to the same device at
    /// once, the mode with the least restrictions is the one actively put into
    /// effect into the underlying device implementation.
    ///
    /// If the device does not support the requested mode, but supports a mode
    /// that is more open than the requested one, `SetMode` succeeds regardless.
    /// Otherwise, if the device only supports *more restrictive* modes than the
    /// one requested, `SetMode` returns `ZX_ERR_NOT_SUPPORTED`.
    ///
    /// Clients must be aware that the resource being accessed is shared, and
    /// that the device may be effectively operating at a more open level than
    /// the one that was requested (although never at one more restrictive).
    ///
    /// + request `mode` request mode to attach to.
    /// - response `status` `ZX_ERR_NOT_SUPPORTED` it the device only supports
    /// mode more restrictive than the one requested.
    SetMode { mode: MacFilterMode, responder: MacAddressingSetModeResponder },
    /// Adds multicast address to the list of multicast groups.
    ///
    /// The list of multicast addresses kept is untouched by calls to `SetMode`.
    /// If the device's mode is not `MULTICAST_FILTER`, the list of multicast
    /// addresses is ignored.
    ///
    /// + request `address` multicast address to add to the list.
    /// - response `status` `ZX_ERR_INVALID_ARGS` if `address` is not a
    /// multicast address.
    /// - response `status` `ZX_ERR_NO_RESOURCES` if there are more than
    /// `MAX_MAC_FILTER` addresses installed.
    AddMulticastAddress {
        address: fdomain_fuchsia_net::MacAddress,
        responder: MacAddressingAddMulticastAddressResponder,
    },
    /// Removes multicast address from the list of multicast groups.
    ///
    /// + request `address` multicast address to remove from the list.
    /// - response `status` `ZX_ERR_INVALID_ARGS` if `address` is not a
    /// multicast address.
    RemoveMulticastAddress {
        address: fdomain_fuchsia_net::MacAddress,
        responder: MacAddressingRemoveMulticastAddressResponder,
    },
}

impl MacAddressingRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_unicast_address(self) -> Option<(MacAddressingGetUnicastAddressResponder)> {
        if let MacAddressingRequest::GetUnicastAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mode(self) -> Option<(MacFilterMode, MacAddressingSetModeResponder)> {
        if let MacAddressingRequest::SetMode { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_multicast_address(
        self,
    ) -> Option<(fdomain_fuchsia_net::MacAddress, MacAddressingAddMulticastAddressResponder)> {
        if let MacAddressingRequest::AddMulticastAddress { address, responder } = self {
            Some((address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_multicast_address(
        self,
    ) -> Option<(fdomain_fuchsia_net::MacAddress, MacAddressingRemoveMulticastAddressResponder)>
    {
        if let MacAddressingRequest::RemoveMulticastAddress { address, responder } = self {
            Some((address, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            MacAddressingRequest::GetUnicastAddress { .. } => "get_unicast_address",
            MacAddressingRequest::SetMode { .. } => "set_mode",
            MacAddressingRequest::AddMulticastAddress { .. } => "add_multicast_address",
            MacAddressingRequest::RemoveMulticastAddress { .. } => "remove_multicast_address",
        }
    }
}

#[derive(Debug, Clone)]
pub struct MacAddressingControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for MacAddressingControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl MacAddressingControlHandle {}

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

/// Set the the channel to be shutdown (see [`MacAddressingControlHandle::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 MacAddressingGetUnicastAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for MacAddressingGetUnicastAddressResponder {
    type ControlHandle = MacAddressingControlHandle;

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

    fn send_raw(&self, mut address: &fdomain_fuchsia_net::MacAddress) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MacAddressingGetUnicastAddressResponse>(
            (address,),
            self.tx_id,
            0x2c60b82a4ecfaebe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`MacAddressingControlHandle::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 MacAddressingSetModeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for MacAddressingSetModeResponder {
    type ControlHandle = MacAddressingControlHandle;

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MacAddressingSetModeResponse>(
            (status,),
            self.tx_id,
            0x6297b8dbf03c58c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`MacAddressingControlHandle::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 MacAddressingAddMulticastAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for MacAddressingAddMulticastAddressResponder {
    type ControlHandle = MacAddressingControlHandle;

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MacAddressingAddMulticastAddressResponse>(
            (status,),
            self.tx_id,
            0xf5637ff11cf0c25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`MacAddressingControlHandle::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 MacAddressingRemoveMulticastAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for MacAddressingRemoveMulticastAddressResponder {
    type ControlHandle = MacAddressingControlHandle;

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MacAddressingRemoveMulticastAddressResponse>(
            (status,),
            self.tx_id,
            0x5dddf4e3ba4e2560,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for PortMarker {
    type Proxy = PortProxy;
    type RequestStream = PortRequestStream;

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

pub trait PortProxyInterface: Send + Sync {
    type GetInfoResponseFut: std::future::Future<Output = Result<PortInfo, fidl::Error>> + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type GetStatusResponseFut: std::future::Future<Output = Result<PortStatus, fidl::Error>> + Send;
    fn r#get_status(&self) -> Self::GetStatusResponseFut;
    fn r#get_status_watcher(
        &self,
        watcher: fdomain_client::fidl::ServerEnd<StatusWatcherMarker>,
        buffer: u32,
    ) -> Result<(), fidl::Error>;
    fn r#get_mac(
        &self,
        mac: fdomain_client::fidl::ServerEnd<MacAddressingMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_device(
        &self,
        device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#clone(&self, port: fdomain_client::fidl::ServerEnd<PortMarker>)
    -> Result<(), fidl::Error>;
    type GetCountersResponseFut: std::future::Future<Output = Result<PortGetCountersResponse, fidl::Error>>
        + Send;
    fn r#get_counters(&self) -> Self::GetCountersResponseFut;
    fn r#get_diagnostics(
        &self,
        diagnostics: fdomain_client::fidl::ServerEnd<DiagnosticsMarker>,
    ) -> Result<(), fidl::Error>;
    type GetIdentityResponseFut: std::future::Future<Output = Result<fdomain_client::Event, fidl::Error>>
        + Send;
    fn r#get_identity(&self) -> Self::GetIdentityResponseFut;
    type GetPowerDependencyTokenResponseFut: std::future::Future<Output = Result<Option<fdomain_client::Event>, fidl::Error>>
        + Send;
    fn r#get_power_dependency_token(&self) -> Self::GetPowerDependencyTokenResponseFut;
}

#[derive(Debug, Clone)]
pub struct PortProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for PortProxy {
    type Protocol = PortMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl PortProxy {
    /// Create a new Proxy for fuchsia.hardware.network/Port.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <PortMarker as fdomain_client::fidl::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) -> PortEventStream {
        PortEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Obtain information about port.
    ///
    /// - response `info` port information.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<PortInfo, fdomain_client::fidl::FDomainResourceDialect>
    {
        PortProxyInterface::r#get_info(self)
    }

    /// Obtain the operating port status.
    ///
    /// - response `status` snapshot of port's current status.
    pub fn r#get_status(
        &self,
    ) -> fidl::client::QueryResponseFut<PortStatus, fdomain_client::fidl::FDomainResourceDialect>
    {
        PortProxyInterface::r#get_status(self)
    }

    /// Connects to a [`StatusWatcher`] to observe port status changes.
    ///
    /// + request `watcher` handle to the status watcher.
    /// + request `buffer` the number of status changes that the client requests
    /// to be stored by `StatusWatcher`. Values are capped at
    /// [`MAX_STATUS_BUFFER`]. A value of 0 or 1 causes the `StatusWatcher` to
    /// not keep any buffers on status changed. Clients that need to observe all
    /// changes to status (as opposed to only the current state) are encouraged
    /// to set a buffer value larger than 1, so that all edges can be observed.
    /// If `StatusWatcher`'s internal queue is filled and new status changes
    /// occur, the oldest samples will be dropped to make room for new ones.
    pub fn r#get_status_watcher(
        &self,
        mut watcher: fdomain_client::fidl::ServerEnd<StatusWatcherMarker>,
        mut buffer: u32,
    ) -> Result<(), fidl::Error> {
        PortProxyInterface::r#get_status_watcher(self, watcher, buffer)
    }

    /// Connects to a [`MacAddressing`] associated with the port.
    ///
    /// + request `mac` mac handle. Closed with `ZX_ERR_NOT_SUPPORTED` if this
    /// port does not support mac addressing.
    pub fn r#get_mac(
        &self,
        mut mac: fdomain_client::fidl::ServerEnd<MacAddressingMarker>,
    ) -> Result<(), fidl::Error> {
        PortProxyInterface::r#get_mac(self, mac)
    }

    /// Connects to the [`Device`] this port belongs to.
    ///
    /// + request `device` grants access to the parent device.
    pub fn r#get_device(
        &self,
        mut device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        PortProxyInterface::r#get_device(self, device)
    }

    /// Establishes a new connection to this port.
    ///
    /// + request `port` the server end for the new connection.
    pub fn r#clone(
        &self,
        mut port: fdomain_client::fidl::ServerEnd<PortMarker>,
    ) -> Result<(), fidl::Error> {
        PortProxyInterface::r#clone(self, port)
    }

    /// Retrieves a snapshot of traffic counters on this port.
    pub fn r#get_counters(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PortGetCountersResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PortProxyInterface::r#get_counters(self)
    }

    /// Grants access to [`Diagnostics`] for this port.
    ///
    /// + request `diagnostics` grants access to diagnostics information.
    pub fn r#get_diagnostics(
        &self,
        mut diagnostics: fdomain_client::fidl::ServerEnd<DiagnosticsMarker>,
    ) -> Result<(), fidl::Error> {
        PortProxyInterface::r#get_diagnostics(self, diagnostics)
    }

    /// Retrieves a unique event handle that is always associated only with
    /// this port.
    ///
    /// This event may be used to uniquely identify a specific port instance
    /// across different APIs in the system.
    pub fn r#get_identity(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PortProxyInterface::r#get_identity(self)
    }

    /// Gets the Power Broker dependency token for this port's power element.
    ///
    /// The token exposes two levels: `0` (off) and `1` (on). Clients lease
    /// level `1` whenever the port's datapath is required and hold the lease
    /// for as long as it is required. Drivers are free to internally
    /// power-manage a leased-but-idle port so long as it's invisible to upper
    /// layers.
    ///
    /// The token is fixed for the lifetime of the port.
    ///
    /// - response `token` absent if this port does not participate in power
    ///   management.
    pub fn r#get_power_dependency_token(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Option<fdomain_client::Event>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PortProxyInterface::r#get_power_dependency_token(self)
    }
}

impl PortProxyInterface for PortProxy {
    type GetInfoResponseFut =
        fidl::client::QueryResponseFut<PortInfo, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PortInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortGetInfoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x276cf65feb554ebd,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PortInfo>(
            (),
            0x276cf65feb554ebd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetStatusResponseFut =
        fidl::client::QueryResponseFut<PortStatus, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_status(&self) -> Self::GetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PortStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortGetStatusResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4235650aacca60b2,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PortStatus>(
            (),
            0x4235650aacca60b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#get_status_watcher(
        &self,
        mut watcher: fdomain_client::fidl::ServerEnd<StatusWatcherMarker>,
        mut buffer: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PortGetStatusWatcherRequest>(
            (watcher, buffer),
            0x65511ab81c1bd8d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_mac(
        &self,
        mut mac: fdomain_client::fidl::ServerEnd<MacAddressingMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PortGetMacRequest>(
            (mac,),
            0x2c6ec2988aefc0f6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_device(
        &self,
        mut device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PortGetDeviceRequest>(
            (device,),
            0x7de34747235d2d80,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#clone(
        &self,
        mut port: fdomain_client::fidl::ServerEnd<PortMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PortCloneRequest>(
            (port,),
            0x4e4764150b4942d3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetCountersResponseFut = fidl::client::QueryResponseFut<
        PortGetCountersResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_counters(&self) -> Self::GetCountersResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PortGetCountersResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortGetCountersResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6a213b03c4fcbbac,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PortGetCountersResponse>(
            (),
            0x6a213b03c4fcbbac,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#get_diagnostics(
        &self,
        mut diagnostics: fdomain_client::fidl::ServerEnd<DiagnosticsMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PortGetDiagnosticsRequest>(
            (diagnostics,),
            0x381faa4ed75e399c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetIdentityResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_identity(&self) -> Self::GetIdentityResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortGetIdentityResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x75134ce0bc114e5a,
            >(_buf?)?;
            Ok(_response.event)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Event>(
            (),
            0x75134ce0bc114e5a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPowerDependencyTokenResponseFut = fidl::client::QueryResponseFut<
        Option<fdomain_client::Event>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_power_dependency_token(&self) -> Self::GetPowerDependencyTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<fdomain_client::Event>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortGetPowerDependencyTokenResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7bec1da6ec2476ed,
            >(_buf?)?;
            Ok(_response.token)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, Option<fdomain_client::Event>>(
                (),
                0x7bec1da6ec2476ed,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct PortEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/Port.
pub struct PortRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for PortRequestStream {
    type Protocol = PortMarker;
    type ControlHandle = PortControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        PortControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for PortRequestStream {
    type Item = Result<PortRequest, 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 PortRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x276cf65feb554ebd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetInfo {
                            responder: PortGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4235650aacca60b2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetStatus {
                            responder: PortGetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x65511ab81c1bd8d4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PortGetStatusWatcherRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PortGetStatusWatcherRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetStatusWatcher {
                            watcher: req.watcher,
                            buffer: req.buffer,

                            control_handle,
                        })
                    }
                    0x2c6ec2988aefc0f6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PortGetMacRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PortGetMacRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetMac { mac: req.mac, control_handle })
                    }
                    0x7de34747235d2d80 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PortGetDeviceRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PortGetDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetDevice { device: req.device, control_handle })
                    }
                    0x4e4764150b4942d3 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PortCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PortCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::Clone { port: req.port, control_handle })
                    }
                    0x6a213b03c4fcbbac => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetCounters {
                            responder: PortGetCountersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x381faa4ed75e399c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PortGetDiagnosticsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PortGetDiagnosticsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetDiagnostics {
                            diagnostics: req.diagnostics,

                            control_handle,
                        })
                    }
                    0x75134ce0bc114e5a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetIdentity {
                            responder: PortGetIdentityResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7bec1da6ec2476ed => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortControlHandle { inner: this.inner.clone() };
                        Ok(PortRequest::GetPowerDependencyToken {
                            responder: PortGetPowerDependencyTokenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PortMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A logical port belonging to a [`Device`].
#[derive(Debug)]
pub enum PortRequest {
    /// Obtain information about port.
    ///
    /// - response `info` port information.
    GetInfo { responder: PortGetInfoResponder },
    /// Obtain the operating port status.
    ///
    /// - response `status` snapshot of port's current status.
    GetStatus { responder: PortGetStatusResponder },
    /// Connects to a [`StatusWatcher`] to observe port status changes.
    ///
    /// + request `watcher` handle to the status watcher.
    /// + request `buffer` the number of status changes that the client requests
    /// to be stored by `StatusWatcher`. Values are capped at
    /// [`MAX_STATUS_BUFFER`]. A value of 0 or 1 causes the `StatusWatcher` to
    /// not keep any buffers on status changed. Clients that need to observe all
    /// changes to status (as opposed to only the current state) are encouraged
    /// to set a buffer value larger than 1, so that all edges can be observed.
    /// If `StatusWatcher`'s internal queue is filled and new status changes
    /// occur, the oldest samples will be dropped to make room for new ones.
    GetStatusWatcher {
        watcher: fdomain_client::fidl::ServerEnd<StatusWatcherMarker>,
        buffer: u32,
        control_handle: PortControlHandle,
    },
    /// Connects to a [`MacAddressing`] associated with the port.
    ///
    /// + request `mac` mac handle. Closed with `ZX_ERR_NOT_SUPPORTED` if this
    /// port does not support mac addressing.
    GetMac {
        mac: fdomain_client::fidl::ServerEnd<MacAddressingMarker>,
        control_handle: PortControlHandle,
    },
    /// Connects to the [`Device`] this port belongs to.
    ///
    /// + request `device` grants access to the parent device.
    GetDevice {
        device: fdomain_client::fidl::ServerEnd<DeviceMarker>,
        control_handle: PortControlHandle,
    },
    /// Establishes a new connection to this port.
    ///
    /// + request `port` the server end for the new connection.
    Clone { port: fdomain_client::fidl::ServerEnd<PortMarker>, control_handle: PortControlHandle },
    /// Retrieves a snapshot of traffic counters on this port.
    GetCounters { responder: PortGetCountersResponder },
    /// Grants access to [`Diagnostics`] for this port.
    ///
    /// + request `diagnostics` grants access to diagnostics information.
    GetDiagnostics {
        diagnostics: fdomain_client::fidl::ServerEnd<DiagnosticsMarker>,
        control_handle: PortControlHandle,
    },
    /// Retrieves a unique event handle that is always associated only with
    /// this port.
    ///
    /// This event may be used to uniquely identify a specific port instance
    /// across different APIs in the system.
    GetIdentity { responder: PortGetIdentityResponder },
    /// Gets the Power Broker dependency token for this port's power element.
    ///
    /// The token exposes two levels: `0` (off) and `1` (on). Clients lease
    /// level `1` whenever the port's datapath is required and hold the lease
    /// for as long as it is required. Drivers are free to internally
    /// power-manage a leased-but-idle port so long as it's invisible to upper
    /// layers.
    ///
    /// The token is fixed for the lifetime of the port.
    ///
    /// - response `token` absent if this port does not participate in power
    ///   management.
    GetPowerDependencyToken { responder: PortGetPowerDependencyTokenResponder },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status(self) -> Option<(PortGetStatusResponder)> {
        if let PortRequest::GetStatus { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status_watcher(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<StatusWatcherMarker>, u32, PortControlHandle)>
    {
        if let PortRequest::GetStatusWatcher { watcher, buffer, control_handle } = self {
            Some((watcher, buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mac(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<MacAddressingMarker>, PortControlHandle)> {
        if let PortRequest::GetMac { mac, control_handle } = self {
            Some((mac, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_device(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<DeviceMarker>, PortControlHandle)> {
        if let PortRequest::GetDevice { device, control_handle } = self {
            Some((device, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<PortMarker>, PortControlHandle)> {
        if let PortRequest::Clone { port, control_handle } = self {
            Some((port, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_counters(self) -> Option<(PortGetCountersResponder)> {
        if let PortRequest::GetCounters { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_diagnostics(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<DiagnosticsMarker>, PortControlHandle)> {
        if let PortRequest::GetDiagnostics { diagnostics, control_handle } = self {
            Some((diagnostics, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_identity(self) -> Option<(PortGetIdentityResponder)> {
        if let PortRequest::GetIdentity { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_power_dependency_token(self) -> Option<(PortGetPowerDependencyTokenResponder)> {
        if let PortRequest::GetPowerDependencyToken { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PortRequest::GetInfo { .. } => "get_info",
            PortRequest::GetStatus { .. } => "get_status",
            PortRequest::GetStatusWatcher { .. } => "get_status_watcher",
            PortRequest::GetMac { .. } => "get_mac",
            PortRequest::GetDevice { .. } => "get_device",
            PortRequest::Clone { .. } => "clone",
            PortRequest::GetCounters { .. } => "get_counters",
            PortRequest::GetDiagnostics { .. } => "get_diagnostics",
            PortRequest::GetIdentity { .. } => "get_identity",
            PortRequest::GetPowerDependencyToken { .. } => "get_power_dependency_token",
        }
    }
}

#[derive(Debug, Clone)]
pub struct PortControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for PortControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl PortControlHandle {}

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

/// Set the the channel to be shutdown (see [`PortControlHandle::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 PortGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortGetInfoResponder {
    type ControlHandle = PortControlHandle;

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

    fn send_raw(&self, mut info: &PortInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PortGetInfoResponse>(
            (info,),
            self.tx_id,
            0x276cf65feb554ebd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`PortControlHandle::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 PortGetStatusResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortGetStatusResponder {
    type ControlHandle = PortControlHandle;

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

    fn send_raw(&self, mut status: &PortStatus) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PortGetStatusResponse>(
            (status,),
            self.tx_id,
            0x4235650aacca60b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`PortControlHandle::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 PortGetCountersResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortGetCountersResponder {
    type ControlHandle = PortControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`PortControlHandle::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 PortGetIdentityResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortGetIdentityResponder {
    type ControlHandle = PortControlHandle;

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

    fn send_raw(&self, mut event: fdomain_client::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PortGetIdentityResponse>(
            (event,),
            self.tx_id,
            0x75134ce0bc114e5a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`PortControlHandle::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 PortGetPowerDependencyTokenResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortGetPowerDependencyTokenResponder {
    type ControlHandle = PortControlHandle;

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

    fn send_raw(&self, mut token: Option<fdomain_client::Event>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PortGetPowerDependencyTokenResponse>(
            (token,),
            self.tx_id,
            0x7bec1da6ec2476ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for PortWatcherMarker {
    type Proxy = PortWatcherProxy;
    type RequestStream = PortWatcherRequestStream;

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

pub trait PortWatcherProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<DevicePortEvent, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
}

#[derive(Debug, Clone)]
pub struct PortWatcherProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for PortWatcherProxy {
    type Protocol = PortWatcherMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl PortWatcherProxy {
    /// Create a new Proxy for fuchsia.hardware.network/PortWatcher.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <PortWatcherMarker as fdomain_client::fidl::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) -> PortWatcherEventStream {
        PortWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get the next port event.
    ///
    /// The first N calls return [`DevicePortEvent.existing`] where N is the
    /// number of ports present on the device at the time of the watcher's
    /// creation. The next call returns [`DevicePortEvent.idle`] to indicate the
    /// end of existing ports. Subsequent calls block until a port is added
    /// ([`DevicePortEvent.added`]) or removed ([`DevicePortEvent.removed`]).
    ///
    /// The server closes the `PortWatcher` channel with `ZX_ERR_CANCELED` if
    /// the number of unread events reaches a server-selected limit that is at
    /// least two times [`MAX_PORTS`]. Clients are encouraged to maintain a
    /// hanging call to `Watch` at all times to avoid triggering this condition.
    ///
    /// - response `event` next port event.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<DevicePortEvent, fdomain_client::fidl::FDomainResourceDialect>
    {
        PortWatcherProxyInterface::r#watch(self)
    }
}

impl PortWatcherProxyInterface for PortWatcherProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        DevicePortEvent,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DevicePortEvent, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PortWatcherWatchResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3e87244b74fff55e,
            >(_buf?)?;
            Ok(_response.event)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DevicePortEvent>(
            (),
            0x3e87244b74fff55e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct PortWatcherEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/PortWatcher.
pub struct PortWatcherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for PortWatcherRequestStream {
    type Protocol = PortWatcherMarker;
    type ControlHandle = PortWatcherControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        PortWatcherControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for PortWatcherRequestStream {
    type Item = Result<PortWatcherRequest, 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 PortWatcherRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x3e87244b74fff55e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PortWatcherControlHandle { inner: this.inner.clone() };
                        Ok(PortWatcherRequest::Watch {
                            responder: PortWatcherWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PortWatcherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides iteration over and updates for ports attached to a device.
#[derive(Debug)]
pub enum PortWatcherRequest {
    /// Get the next port event.
    ///
    /// The first N calls return [`DevicePortEvent.existing`] where N is the
    /// number of ports present on the device at the time of the watcher's
    /// creation. The next call returns [`DevicePortEvent.idle`] to indicate the
    /// end of existing ports. Subsequent calls block until a port is added
    /// ([`DevicePortEvent.added`]) or removed ([`DevicePortEvent.removed`]).
    ///
    /// The server closes the `PortWatcher` channel with `ZX_ERR_CANCELED` if
    /// the number of unread events reaches a server-selected limit that is at
    /// least two times [`MAX_PORTS`]. Clients are encouraged to maintain a
    /// hanging call to `Watch` at all times to avoid triggering this condition.
    ///
    /// - response `event` next port event.
    Watch { responder: PortWatcherWatchResponder },
}

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

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

#[derive(Debug, Clone)]
pub struct PortWatcherControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for PortWatcherControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl PortWatcherControlHandle {}

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

/// Set the the channel to be shutdown (see [`PortWatcherControlHandle::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 PortWatcherWatchResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for PortWatcherWatchResponder {
    type ControlHandle = PortWatcherControlHandle;

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

    fn send_raw(&self, mut event: &DevicePortEvent) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PortWatcherWatchResponse>(
            (event,),
            self.tx_id,
            0x3e87244b74fff55e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for SessionMarker {
    type Proxy = SessionProxy;
    type RequestStream = SessionRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Session";
}
pub type SessionAttachResult = Result<(), i32>;
pub type SessionDetachResult = Result<(), i32>;

pub trait SessionProxyInterface: Send + Sync {
    type AttachResponseFut: std::future::Future<Output = Result<SessionAttachResult, fidl::Error>>
        + Send;
    fn r#attach(&self, port: &PortId, rx_frames: &[FrameType]) -> Self::AttachResponseFut;
    type DetachResponseFut: std::future::Future<Output = Result<SessionDetachResult, fidl::Error>>
        + Send;
    fn r#detach(&self, port: &PortId) -> Self::DetachResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    type WatchDelegatedRxLeaseResponseFut: std::future::Future<Output = Result<DelegatedRxLease, fidl::Error>>
        + Send;
    fn r#watch_delegated_rx_lease(&self) -> Self::WatchDelegatedRxLeaseResponseFut;
    type RegisterForTxResponseFut: std::future::Future<Output = Result<(u8, i32), fidl::Error>>
        + Send;
    fn r#register_for_tx(&self, vmos: &[u8]) -> Self::RegisterForTxResponseFut;
    type UnregisterForTxResponseFut: std::future::Future<Output = Result<(u8, i32), fidl::Error>>
        + Send;
    fn r#unregister_for_tx(&self, vmos: &[u8]) -> Self::UnregisterForTxResponseFut;
}

#[derive(Debug, Clone)]
pub struct SessionProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for SessionProxy {
    type Protocol = SessionMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl SessionProxy {
    /// Create a new Proxy for fuchsia.hardware.network/Session.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SessionMarker as fdomain_client::fidl::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) -> SessionEventStream {
        SessionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Attaches the session to `port`.
    ///
    /// Once attached, the session starts to receive the subscribed frames over
    /// the data FIFOs and it may send frames destined to the specified `port`.
    ///
    /// + request `port` port to subscribe to.
    /// + request `rx_frames` Frame types of interest on the port.
    /// * error `ZX_ERR_NOT_FOUND` if `port` is not valid.
    /// * error `ZX_ERR_INVALID_ARGS` if `rx_frames` is not a subset of the
    /// port's supported frames.
    /// * error `ZX_ERR_ALREADY_BOUND` if `port` is already attached.
    pub fn r#attach(
        &self,
        mut port: &PortId,
        mut rx_frames: &[FrameType],
    ) -> fidl::client::QueryResponseFut<
        SessionAttachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SessionProxyInterface::r#attach(self, port, rx_frames)
    }

    /// Detaches the session from `port`.
    ///
    /// Once detached, the session stops receiving frames from `port`. Frames
    /// sent to a detached port may be returned with an error. It is not
    /// necessary to call `Detach` on ports that are removed from the device,
    /// doing so causes `ZX_ERR_NOT_FOUND` to be returned.
    ///
    /// + request `port` port to subscribe to.
    /// * error `ZX_ERR_NOT_FOUND` if the session is not currently attached to
    /// the port.
    pub fn r#detach(
        &self,
        mut port: &PortId,
    ) -> fidl::client::QueryResponseFut<
        SessionDetachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SessionProxyInterface::r#detach(self, port)
    }

    /// Cleanly closes a session.
    ///
    /// This will cause the session to send a `ZX_ERR_CANCELLED` epitaph and
    /// proceed to close the Session channel. Clients may only assume that they
    /// own all the buffers that are currently owned by the session (sent over
    /// either the rx or tx FIFOs) once the epitaph is received. Closing the rx
    /// or tx FIFO is equivalent to calling `Close`.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        SessionProxyInterface::r#close(self)
    }

    /// Watchers for delegated receive wakeup leases.
    ///
    /// Calls block until a lease is delegated by the device. If a call to
    /// `WatchDelegatedRxLease` is made while a previous call is blocking, the
    /// session is closed with `ZX_ERR_BAD_STATE`. Will never yield any values
    /// for sessions created without [`SessionFlags.RECEIVE_RX_POWER_LEASES`].
    ///
    /// Given a single lease is assumed sufficient to keep the system awake, the
    /// server only keeps a single lease in its buffer. If a new delegated lease
    /// becomes available and the client hasn't popped the previous one with a
    /// call to `WatchDelegatedRxLease`, the server drops the previously pending
    /// lease.
    ///
    /// See [`DelegatedRxLease`] for how to handle delegated leases.
    pub fn r#watch_delegated_rx_lease(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DelegatedRxLease,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SessionProxyInterface::r#watch_delegated_rx_lease(self)
    }

    /// Asks the network device to register the VMO for Tx.
    ///
    /// The network device prepares the VMOs in order and stops at the first
    /// error if any. It returns how many VMOs have been prepared alongside with
    /// the first error encountered. Note that network-device itself does not
    /// try to release earlier VMOs for a later error. It is up to the client
    /// how to recover from an error.
    ///
    /// * error `ZX_ERR_NOT_FOUND` if any of the VmoId is unknown.
    /// * error other zx status that can be reported by the driver.
    pub fn r#register_for_tx(
        &self,
        mut vmos: &[u8],
    ) -> fidl::client::QueryResponseFut<(u8, i32), fdomain_client::fidl::FDomainResourceDialect>
    {
        SessionProxyInterface::r#register_for_tx(self, vmos)
    }

    /// Tells the device that the client will no longer use the VMO for Tx,
    /// if the VMO is also unused for Rx, the device is free to release it
    /// at the implementation driver.
    ///
    /// The network device processes the VMOs in order and stops at the first
    /// error if any. It returns how many VMOs have been marked as unused for Tx
    /// alongside with the first error encountered. Note that network-device
    /// itself does not try to re-register earlier VMOs for a later error. It is
    /// up to the client how to recover from an error.
    ///
    /// * error `ZX_ERR_NOT_FOUND` if any of the VmoId is unknown.
    /// * error other zx status that can be reported by the driver.
    pub fn r#unregister_for_tx(
        &self,
        mut vmos: &[u8],
    ) -> fidl::client::QueryResponseFut<(u8, i32), fdomain_client::fidl::FDomainResourceDialect>
    {
        SessionProxyInterface::r#unregister_for_tx(self, vmos)
    }
}

impl SessionProxyInterface for SessionProxy {
    type AttachResponseFut = fidl::client::QueryResponseFut<
        SessionAttachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#attach(&self, mut port: &PortId, mut rx_frames: &[FrameType]) -> Self::AttachResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionAttachResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1e89c9013e201379,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SessionAttachRequest, SessionAttachResult>(
            (port, rx_frames),
            0x1e89c9013e201379,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DetachResponseFut = fidl::client::QueryResponseFut<
        SessionDetachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#detach(&self, mut port: &PortId) -> Self::DetachResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionDetachResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x68c40cf8fb549867,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SessionDetachRequest, SessionDetachResult>(
            (port,),
            0x68c40cf8fb549867,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type WatchDelegatedRxLeaseResponseFut = fidl::client::QueryResponseFut<
        DelegatedRxLease,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_delegated_rx_lease(&self) -> Self::WatchDelegatedRxLeaseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DelegatedRxLease, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SessionWatchDelegatedRxLeaseResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x764d823ee64803b5,
            >(_buf?)?;
            Ok(_response.lease)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DelegatedRxLease>(
            (),
            0x764d823ee64803b5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterForTxResponseFut =
        fidl::client::QueryResponseFut<(u8, i32), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#register_for_tx(&self, mut vmos: &[u8]) -> Self::RegisterForTxResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u8, i32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SessionRegisterForTxResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x36321799ce2a081a,
            >(_buf?)?;
            Ok((_response.successful, _response.status))
        }
        self.client.send_query_and_decode::<SessionRegisterForTxRequest, (u8, i32)>(
            (vmos,),
            0x36321799ce2a081a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnregisterForTxResponseFut =
        fidl::client::QueryResponseFut<(u8, i32), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#unregister_for_tx(&self, mut vmos: &[u8]) -> Self::UnregisterForTxResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u8, i32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SessionUnregisterForTxResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3e76b16030d62796,
            >(_buf?)?;
            Ok((_response.successful, _response.status))
        }
        self.client.send_query_and_decode::<SessionUnregisterForTxRequest, (u8, i32)>(
            (vmos,),
            0x3e76b16030d62796,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct SessionEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/Session.
pub struct SessionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for SessionRequestStream {
    type Protocol = SessionMarker;
    type ControlHandle = SessionControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        SessionControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for SessionRequestStream {
    type Item = Result<SessionRequest, 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 SessionRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x1e89c9013e201379 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionAttachRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SessionAttachRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Attach {
                            port: req.port,
                            rx_frames: req.rx_frames,

                            responder: SessionAttachResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68c40cf8fb549867 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionDetachRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SessionDetachRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Detach {
                            port: req.port,

                            responder: SessionDetachResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x393d5070394a92f6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Close { control_handle })
                    }
                    0x764d823ee64803b5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::WatchDelegatedRxLease {
                            responder: SessionWatchDelegatedRxLeaseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x36321799ce2a081a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionRegisterForTxRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SessionRegisterForTxRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::RegisterForTx {
                            vmos: req.vmos,

                            responder: SessionRegisterForTxResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3e76b16030d62796 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionUnregisterForTxRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SessionUnregisterForTxRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::UnregisterForTx {
                            vmos: req.vmos,

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

/// Represents a session with a Network device.
///
/// A session has a data plane and a control plane. The `Session` protocol
/// represents the control plane of the session and the FIFOs and VMOs exchanged
/// during the [`Device.OpenSession`] call are the data plane. Lifetime of the
/// session is controlled by a `Session` protocol handle.
///
/// Sessions must attach to ports of interest to start receiving and sending
/// data. Sessions are always created with no ports attached.
///
/// If a port is destroyed from the underlying device, it is automatically
/// detached from the session.
///
/// Inbound traffic is dispatched to all open sessions. Devices typically
/// operate with a single primary session, see [`SessionFlags.PRIMARY`]. Each
/// additional open session to the same device causes data copy overhead on the
/// device's data path.
///
/// The session is closed with an error epitaph if an invalid buffer descriptor
/// is sent over either the tx or rx FIFOs. Invalid descriptors include:
///    - Descriptor index larger than [`SessionInfo.descriptor_count`].
///    - Descriptor chains larger than [`MAX_DESCRIPTOR_CHAIN`].
///    - rx buffers smaller than [`Info.min_rx_buffer_length`].
///    - tx buffers smaller than [`Info.min_tx_buffer_length`].
///    - tx buffers not respecting [`Info.min_tx_buffer_head`] or
///      [`Info.min_tx_buffer_tail`].
#[derive(Debug)]
pub enum SessionRequest {
    /// Attaches the session to `port`.
    ///
    /// Once attached, the session starts to receive the subscribed frames over
    /// the data FIFOs and it may send frames destined to the specified `port`.
    ///
    /// + request `port` port to subscribe to.
    /// + request `rx_frames` Frame types of interest on the port.
    /// * error `ZX_ERR_NOT_FOUND` if `port` is not valid.
    /// * error `ZX_ERR_INVALID_ARGS` if `rx_frames` is not a subset of the
    /// port's supported frames.
    /// * error `ZX_ERR_ALREADY_BOUND` if `port` is already attached.
    Attach { port: PortId, rx_frames: Vec<FrameType>, responder: SessionAttachResponder },
    /// Detaches the session from `port`.
    ///
    /// Once detached, the session stops receiving frames from `port`. Frames
    /// sent to a detached port may be returned with an error. It is not
    /// necessary to call `Detach` on ports that are removed from the device,
    /// doing so causes `ZX_ERR_NOT_FOUND` to be returned.
    ///
    /// + request `port` port to subscribe to.
    /// * error `ZX_ERR_NOT_FOUND` if the session is not currently attached to
    /// the port.
    Detach { port: PortId, responder: SessionDetachResponder },
    /// Cleanly closes a session.
    ///
    /// This will cause the session to send a `ZX_ERR_CANCELLED` epitaph and
    /// proceed to close the Session channel. Clients may only assume that they
    /// own all the buffers that are currently owned by the session (sent over
    /// either the rx or tx FIFOs) once the epitaph is received. Closing the rx
    /// or tx FIFO is equivalent to calling `Close`.
    Close { control_handle: SessionControlHandle },
    /// Watchers for delegated receive wakeup leases.
    ///
    /// Calls block until a lease is delegated by the device. If a call to
    /// `WatchDelegatedRxLease` is made while a previous call is blocking, the
    /// session is closed with `ZX_ERR_BAD_STATE`. Will never yield any values
    /// for sessions created without [`SessionFlags.RECEIVE_RX_POWER_LEASES`].
    ///
    /// Given a single lease is assumed sufficient to keep the system awake, the
    /// server only keeps a single lease in its buffer. If a new delegated lease
    /// becomes available and the client hasn't popped the previous one with a
    /// call to `WatchDelegatedRxLease`, the server drops the previously pending
    /// lease.
    ///
    /// See [`DelegatedRxLease`] for how to handle delegated leases.
    WatchDelegatedRxLease { responder: SessionWatchDelegatedRxLeaseResponder },
    /// Asks the network device to register the VMO for Tx.
    ///
    /// The network device prepares the VMOs in order and stops at the first
    /// error if any. It returns how many VMOs have been prepared alongside with
    /// the first error encountered. Note that network-device itself does not
    /// try to release earlier VMOs for a later error. It is up to the client
    /// how to recover from an error.
    ///
    /// * error `ZX_ERR_NOT_FOUND` if any of the VmoId is unknown.
    /// * error other zx status that can be reported by the driver.
    RegisterForTx { vmos: Vec<u8>, responder: SessionRegisterForTxResponder },
    /// Tells the device that the client will no longer use the VMO for Tx,
    /// if the VMO is also unused for Rx, the device is free to release it
    /// at the implementation driver.
    ///
    /// The network device processes the VMOs in order and stops at the first
    /// error if any. It returns how many VMOs have been marked as unused for Tx
    /// alongside with the first error encountered. Note that network-device
    /// itself does not try to re-register earlier VMOs for a later error. It is
    /// up to the client how to recover from an error.
    ///
    /// * error `ZX_ERR_NOT_FOUND` if any of the VmoId is unknown.
    /// * error other zx status that can be reported by the driver.
    UnregisterForTx { vmos: Vec<u8>, responder: SessionUnregisterForTxResponder },
}

impl SessionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_attach(self) -> Option<(PortId, Vec<FrameType>, SessionAttachResponder)> {
        if let SessionRequest::Attach { port, rx_frames, responder } = self {
            Some((port, rx_frames, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_detach(self) -> Option<(PortId, SessionDetachResponder)> {
        if let SessionRequest::Detach { port, responder } = self {
            Some((port, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(SessionControlHandle)> {
        if let SessionRequest::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_delegated_rx_lease(self) -> Option<(SessionWatchDelegatedRxLeaseResponder)> {
        if let SessionRequest::WatchDelegatedRxLease { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_for_tx(self) -> Option<(Vec<u8>, SessionRegisterForTxResponder)> {
        if let SessionRequest::RegisterForTx { vmos, responder } = self {
            Some((vmos, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_for_tx(self) -> Option<(Vec<u8>, SessionUnregisterForTxResponder)> {
        if let SessionRequest::UnregisterForTx { vmos, responder } = self {
            Some((vmos, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SessionRequest::Attach { .. } => "attach",
            SessionRequest::Detach { .. } => "detach",
            SessionRequest::Close { .. } => "close",
            SessionRequest::WatchDelegatedRxLease { .. } => "watch_delegated_rx_lease",
            SessionRequest::RegisterForTx { .. } => "register_for_tx",
            SessionRequest::UnregisterForTx { .. } => "unregister_for_tx",
        }
    }
}

#[derive(Debug, Clone)]
pub struct SessionControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for SessionControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl SessionControlHandle {}

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

/// Set the the channel to be shutdown (see [`SessionControlHandle::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 SessionAttachResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for SessionAttachResponder {
    type ControlHandle = SessionControlHandle;

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

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

/// Set the the channel to be shutdown (see [`SessionControlHandle::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 SessionDetachResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for SessionDetachResponder {
    type ControlHandle = SessionControlHandle;

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

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

/// Set the the channel to be shutdown (see [`SessionControlHandle::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 SessionWatchDelegatedRxLeaseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for SessionWatchDelegatedRxLeaseResponder {
    type ControlHandle = SessionControlHandle;

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

    fn send_raw(&self, mut lease: DelegatedRxLease) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SessionWatchDelegatedRxLeaseResponse>(
            (&mut lease,),
            self.tx_id,
            0x764d823ee64803b5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`SessionControlHandle::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 SessionRegisterForTxResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for SessionRegisterForTxResponder {
    type ControlHandle = SessionControlHandle;

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

    fn send_raw(&self, mut successful: u8, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SessionRegisterForTxResponse>(
            (successful, status),
            self.tx_id,
            0x36321799ce2a081a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`SessionControlHandle::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 SessionUnregisterForTxResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for SessionUnregisterForTxResponder {
    type ControlHandle = SessionControlHandle;

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

    fn send_raw(&self, mut successful: u8, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SessionUnregisterForTxResponse>(
            (successful, status),
            self.tx_id,
            0x3e76b16030d62796,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for StatusWatcherMarker {
    type Proxy = StatusWatcherProxy;
    type RequestStream = StatusWatcherRequestStream;

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

pub trait StatusWatcherProxyInterface: Send + Sync {
    type WatchStatusResponseFut: std::future::Future<Output = Result<PortStatus, fidl::Error>>
        + Send;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut;
}

#[derive(Debug, Clone)]
pub struct StatusWatcherProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for StatusWatcherProxy {
    type Protocol = StatusWatcherMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl StatusWatcherProxy {
    /// Create a new Proxy for fuchsia.hardware.network/StatusWatcher.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <StatusWatcherMarker as fdomain_client::fidl::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) -> StatusWatcherEventStream {
        StatusWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// `WatchStatus` blocks until the port's status has changed.
    ///
    /// The first call to `WatchStatus` returns immediately with the current
    /// port status, subsequent calls complete when the port status differs from
    /// the last one that was returned through this `StatusWatcher`.
    ///
    /// If `StatusWatcher` was created with a buffer value larger than 1,
    /// `WatchStatus` may return a queued status change, depending on how many
    /// status changed happened since the last call to `WatchStatus`.
    ///
    /// - response `device_status` the most recent port status.
    pub fn r#watch_status(
        &self,
    ) -> fidl::client::QueryResponseFut<PortStatus, fdomain_client::fidl::FDomainResourceDialect>
    {
        StatusWatcherProxyInterface::r#watch_status(self)
    }
}

impl StatusWatcherProxyInterface for StatusWatcherProxy {
    type WatchStatusResponseFut =
        fidl::client::QueryResponseFut<PortStatus, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PortStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StatusWatcherWatchStatusResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1369a8125c0862b9,
            >(_buf?)?;
            Ok(_response.port_status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PortStatus>(
            (),
            0x1369a8125c0862b9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct StatusWatcherEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.network/StatusWatcher.
pub struct StatusWatcherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for StatusWatcherRequestStream {
    type Protocol = StatusWatcherMarker;
    type ControlHandle = StatusWatcherControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        StatusWatcherControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for StatusWatcherRequestStream {
    type Item = Result<StatusWatcherRequest, 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 StatusWatcherRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                0x1369a8125c0862b9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StatusWatcherControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StatusWatcherRequest::WatchStatus {
                        responder: StatusWatcherWatchStatusResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <StatusWatcherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides a way to receive updates on port status changes.
#[derive(Debug)]
pub enum StatusWatcherRequest {
    /// `WatchStatus` blocks until the port's status has changed.
    ///
    /// The first call to `WatchStatus` returns immediately with the current
    /// port status, subsequent calls complete when the port status differs from
    /// the last one that was returned through this `StatusWatcher`.
    ///
    /// If `StatusWatcher` was created with a buffer value larger than 1,
    /// `WatchStatus` may return a queued status change, depending on how many
    /// status changed happened since the last call to `WatchStatus`.
    ///
    /// - response `device_status` the most recent port status.
    WatchStatus { responder: StatusWatcherWatchStatusResponder },
}

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

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

#[derive(Debug, Clone)]
pub struct StatusWatcherControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::ControlHandle for StatusWatcherControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl StatusWatcherControlHandle {}

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

/// Set the the channel to be shutdown (see [`StatusWatcherControlHandle::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 StatusWatcherWatchStatusResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for StatusWatcherWatchStatusResponder {
    type ControlHandle = StatusWatcherControlHandle;

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

    fn send_raw(&self, mut port_status: &PortStatus) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StatusWatcherWatchStatusResponse>(
            (port_status,),
            self.tx_id,
            0x1369a8125c0862b9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DeviceCloneRequest {
        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 DeviceCloneRequest {
        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<DeviceCloneRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DeviceCloneRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceCloneRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceCloneRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<DeviceCloneRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceCloneRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for DeviceCloneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.device,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceGetPortRequest {
        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 DeviceGetPortRequest {
        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<DeviceGetPortRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DeviceGetPortRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetPortRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceGetPortRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <PortId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.port),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<PortId, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<DeviceGetPortRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetPortRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DeviceGetPortRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(PortId, fdomain_client::fidl::FDomainResourceDialect),
                port: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DeviceGetPortWatcherRequest {
        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 DeviceGetPortWatcherRequest {
        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<
            DeviceGetPortWatcherRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DeviceGetPortWatcherRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetPortWatcherRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceGetPortWatcherRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DeviceGetPortWatcherRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetPortWatcherRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for DeviceGetPortWatcherRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortWatcherMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<PortWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.watcher,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DeviceOpenSessionRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DeviceOpenSessionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOpenSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DeviceOpenSessionRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.session_name,
                    ),
                    <SessionInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.session_info,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<SessionInfo, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            DeviceOpenSessionRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOpenSessionRequest>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DeviceOpenSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session_name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                session_info: fidl::new_empty!(
                    SessionInfo,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DeviceOpenSessionResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DeviceOpenSessionResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOpenSessionResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceOpenSessionResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<SessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                    <Fifos as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.fifos),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<Fifos, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            DeviceOpenSessionResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOpenSessionResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for DeviceOpenSessionResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<SessionMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                fifos: fidl::new_empty!(Fifos, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ClientEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Fifos,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.fifos,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Fifos {
        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 Fifos {
        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<Fifos, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Fifos
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Fifos>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Fifos, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::Fifo,
                        { fidl::ObjectType::FIFO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.rx
                    ),
                    <fidl::encoding::HandleType<
                        fdomain_client::Fifo,
                        { fidl::ObjectType::FIFO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.tx
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Fifo,
                    { fidl::ObjectType::FIFO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Fifo,
                    { fidl::ObjectType::FIFO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<Fifos, fdomain_client::fidl::FDomainResourceDialect> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Fifos>(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, fdomain_client::fidl::FDomainResourceDialect> for Fifos {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                rx: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                tx: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.rx, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.tx, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortCloneRequest {
        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 PortCloneRequest {
        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<PortCloneRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut PortCloneRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortCloneRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PortCloneRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.port),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<PortCloneRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortCloneRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortCloneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                port: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<PortMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<PortMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.port,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetDeviceRequest {
        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 PortGetDeviceRequest {
        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<PortGetDeviceRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut PortGetDeviceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetDeviceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PortGetDeviceRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<PortGetDeviceRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetDeviceRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetDeviceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<DeviceMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.device,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetDiagnosticsRequest {
        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 PortGetDiagnosticsRequest {
        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<
            PortGetDiagnosticsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PortGetDiagnosticsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetDiagnosticsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PortGetDiagnosticsRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DiagnosticsMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.diagnostics),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DiagnosticsMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PortGetDiagnosticsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetDiagnosticsRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetDiagnosticsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                diagnostics: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DiagnosticsMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<DiagnosticsMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.diagnostics,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetIdentityResponse {
        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 PortGetIdentityResponse {
        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<
            PortGetIdentityResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PortGetIdentityResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetIdentityResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PortGetIdentityResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    3,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.event
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    3,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PortGetIdentityResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetIdentityResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetIdentityResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                event: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 3>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 3>, fdomain_client::fidl::FDomainResourceDialect, &mut self.event, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetMacRequest {
        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 PortGetMacRequest {
        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<PortGetMacRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut PortGetMacRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetMacRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PortGetMacRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<MacAddressingMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.mac),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<MacAddressingMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<PortGetMacRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetMacRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetMacRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mac: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<MacAddressingMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<MacAddressingMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.mac,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetPowerDependencyTokenResponse {
        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 PortGetPowerDependencyTokenResponse {
        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<
            PortGetPowerDependencyTokenResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PortGetPowerDependencyTokenResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetPowerDependencyTokenResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PortGetPowerDependencyTokenResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.token
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PortGetPowerDependencyTokenResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetPowerDependencyTokenResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetPowerDependencyTokenResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.token,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PortGetStatusWatcherRequest {
        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 PortGetStatusWatcherRequest {
        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<
            PortGetStatusWatcherRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PortGetStatusWatcherRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetStatusWatcherRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PortGetStatusWatcherRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StatusWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StatusWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            PortGetStatusWatcherRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PortGetStatusWatcherRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for PortGetStatusWatcherRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StatusWatcherMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                buffer: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<StatusWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.watcher,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffer,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SessionRegisterForTxRequest {
        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 SessionRegisterForTxRequest {
        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<
            SessionRegisterForTxRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut SessionRegisterForTxRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionRegisterForTxRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SessionRegisterForTxRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.vmos,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<u8, 32>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            SessionRegisterForTxRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionRegisterForTxRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionRegisterForTxRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmos: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for SessionUnregisterForTxRequest {
        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 SessionUnregisterForTxRequest {
        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<
            SessionUnregisterForTxRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut SessionUnregisterForTxRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionUnregisterForTxRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SessionUnregisterForTxRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.vmos,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<u8, 32>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            SessionUnregisterForTxRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionUnregisterForTxRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionUnregisterForTxRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmos: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for SessionWatchDelegatedRxLeaseResponse {
        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 SessionWatchDelegatedRxLeaseResponse {
        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<
            SessionWatchDelegatedRxLeaseResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut SessionWatchDelegatedRxLeaseResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionWatchDelegatedRxLeaseResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SessionWatchDelegatedRxLeaseResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<DelegatedRxLease as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.lease,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<DelegatedRxLease, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            SessionWatchDelegatedRxLeaseResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionWatchDelegatedRxLeaseResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionWatchDelegatedRxLeaseResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                lease: fidl::new_empty!(
                    DelegatedRxLease,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl DataVmo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.num_rx_buffers {
                return 3;
            }
            if let Some(_) = self.vmo {
                return 2;
            }
            if let Some(_) = self.id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DataVmo {
        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 DataVmo {
        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<DataVmo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DataVmo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DataVmo>(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::<
                u8,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.id.as_ref().map(<u8 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::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.vmo.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > 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::<
                u16,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.num_rx_buffers.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for DataVmo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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 =
                    <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.id.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u8,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > 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.vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, 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 =
                    <u16 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.num_rx_buffers.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u16,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 DelegatedRxLease {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.handle {
                return 2;
            }
            if let Some(_) = self.hold_until_frame {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DelegatedRxLease {
        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 DelegatedRxLease {
        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<DelegatedRxLease, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DelegatedRxLease
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DelegatedRxLease>(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::<
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.hold_until_frame
                    .as_ref()
                    .map(<u64 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::<
                DelegatedRxLeaseHandle,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.handle.as_mut().map(
                    <DelegatedRxLeaseHandle as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DelegatedRxLease
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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 =
                    <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.hold_until_frame.get_or_insert_with(|| {
                    fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 =
                    <DelegatedRxLeaseHandle 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.handle.get_or_insert_with(|| {
                    fidl::new_empty!(
                        DelegatedRxLeaseHandle,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    DelegatedRxLeaseHandle,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 SessionInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.options {
                return 6;
            }
            if let Some(_) = self.descriptor_count {
                return 5;
            }
            if let Some(_) = self.descriptor_length {
                return 4;
            }
            if let Some(_) = self.descriptor_version {
                return 3;
            }
            if let Some(_) = self.data {
                return 2;
            }
            if let Some(_) = self.descriptors {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SessionInfo {
        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 SessionInfo {
        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<SessionInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut SessionInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionInfo>(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::<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.descriptors.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::Vector<DataVmo, 32>, fdomain_client::fidl::FDomainResourceDialect>(
            self.data.as_mut().map(<fidl::encoding::Vector<DataVmo, 32> 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::<
                u8,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.descriptor_version
                    .as_ref()
                    .map(<u8 as fidl::encoding::ValueTypeMarker>::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::<
                u8,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.descriptor_length
                    .as_ref()
                    .map(<u8 as fidl::encoding::ValueTypeMarker>::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::<
                u16,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.descriptor_count
                    .as_ref()
                    .map(<u16 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::<
                SessionFlags,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.options
                    .as_ref()
                    .map(<SessionFlags as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for SessionInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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 = <fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > 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.descriptors.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, 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::Vector<DataVmo, 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.data.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<DataVmo, 32>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<DataVmo, 32>, fdomain_client::fidl::FDomainResourceDialect, 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 =
                    <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.descriptor_version.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u8,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 =
                    <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.descriptor_length.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u8,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 =
                    <u16 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.descriptor_count.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u16,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 =
                    <SessionFlags 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.options.get_or_insert_with(|| {
                    fidl::new_empty!(SessionFlags, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    SessionFlags,
                    fdomain_client::fidl::FDomainResourceDialect,
                    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 DelegatedRxLeaseHandle {
        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 DelegatedRxLeaseHandle {
        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<DelegatedRxLeaseHandle, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DelegatedRxLeaseHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DelegatedRxLeaseHandle>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                DelegatedRxLeaseHandle::Channel(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::HandleType<
                            fdomain_client::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fdomain_client::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                DelegatedRxLeaseHandle::Eventpair(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::HandleType<
                            fdomain_client::EventPair,
                            { fidl::ObjectType::EVENTPAIR.into_raw() },
                            16387,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fdomain_client::EventPair,
                            { fidl::ObjectType::EVENTPAIR.into_raw() },
                            16387,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                DelegatedRxLeaseHandle::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DelegatedRxLeaseHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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::HandleType<
                    fdomain_client::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    16387,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            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 DelegatedRxLeaseHandle::Channel(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = DelegatedRxLeaseHandle::Channel(
                            fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let DelegatedRxLeaseHandle::Channel(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let DelegatedRxLeaseHandle::Eventpair(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = DelegatedRxLeaseHandle::Eventpair(
                            fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 16387>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let DelegatedRxLeaseHandle::Eventpair(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 16387>, fdomain_client::fidl::FDomainResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = DelegatedRxLeaseHandle::__SourceBreaking { unknown_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(())
        }
    }
}