fdomain_fuchsia_net_debug/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DiagnosticsGetProcessHandleForInspectionResponse {
    pub process: fdomain_client::Process,
}

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PacketCaptureProviderReconnectRollingRequest {
    /// A name previously passed to [`RollingPacketCapture/Detach`]
    /// that identifies this packet capture.
    pub name: String,
}

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

#[derive(Debug, PartialEq)]
pub struct PacketCaptureProviderStartRollingRequest {
    pub common_params: CommonPacketCaptureParams,
    pub params: RollingPacketCaptureParams,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PacketCaptureProviderReconnectRollingResponse {
    pub channel: fdomain_client::fidl::ClientEnd<RollingPacketCaptureMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PacketCaptureProviderStartRollingResponse {
    pub channel: fdomain_client::fidl::ClientEnd<RollingPacketCaptureMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RollingPacketCaptureStopAndDownloadRequest {
    /// Channel over which the client can download the packet capture. The
    /// file is always read-only.
    pub channel: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
}

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

/// Parameters common to all packet capturing modes.
#[derive(Debug, Default, PartialEq)]
pub struct CommonPacketCaptureParams {
    /// Which interface(s) to capture on.
    ///
    /// Required.
    pub interfaces: Option<InterfaceSpecifier>,
    /// eBPF program for deciding which packets are included in
    /// the capture. The program must not make use of any eBPF-only
    /// features not present in cBPF. The program must be of type
    /// BPF_PROG_TYPE_SOCKET_FILTER and have been verified as such.
    ///
    /// Optional.
    pub bpf_program: Option<fdomain_fuchsia_ebpf::VerifiedProgram>,
    /// Number of bytes from the start of each packet to save in the capture.
    /// Truncation only happens at the end of the packet, no headers are skipped.
    ///
    /// Optional, [`DEFAULT_SNAP_LEN`] is used if absent or 0 is passed.
    pub snap_len: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[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 = "fuchsia.net.debug.Diagnostics";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for DiagnosticsMarker {}

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;
    type GetProcessHandleForInspectionResponseFut: std::future::Future<Output = Result<fdomain_client::Process, fidl::Error>>
        + Send;
    fn r#get_process_handle_for_inspection(&self)
    -> Self::GetProcessHandleForInspectionResponseFut;
}

#[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.net.debug/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 network stack produces debugging information in the
    /// system logs.
    ///
    /// The call returns once 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)
    }

    /// Requests a handle to the netstack's process.
    ///
    /// This handle is not meant to be used for anything other than diagnostics,
    /// so only the `INSPECT` right is provided to the caller.
    pub fn r#get_process_handle_for_inspection(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Process,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DiagnosticsProxyInterface::r#get_process_handle_for_inspection(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,
                0x336c39330bd8e1ac,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x336c39330bd8e1ac,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetProcessHandleForInspectionResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Process,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_process_handle_for_inspection(
        &self,
    ) -> Self::GetProcessHandleForInspectionResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Process, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DiagnosticsGetProcessHandleForInspectionResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x563e5df030f2f4d5,
            >(_buf?)?;
            Ok(_response.process)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Process>(
            (),
            0x563e5df030f2f4d5,
            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.net.debug/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 {
                    0x336c39330bd8e1ac => {
                        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,
                            },
                        })
                    }
                    0x563e5df030f2f4d5 => {
                        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::GetProcessHandleForInspection {
                            responder: DiagnosticsGetProcessHandleForInspectionResponder {
                                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 access to Network stack diagnostics information.
#[derive(Debug)]
pub enum DiagnosticsRequest {
    /// Requests that the network stack produces debugging information in the
    /// system logs.
    ///
    /// The call returns once debug information has been produced.
    LogDebugInfoToSyslog { responder: DiagnosticsLogDebugInfoToSyslogResponder },
    /// Requests a handle to the netstack's process.
    ///
    /// This handle is not meant to be used for anything other than diagnostics,
    /// so only the `INSPECT` right is provided to the caller.
    GetProcessHandleForInspection { responder: DiagnosticsGetProcessHandleForInspectionResponder },
}

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
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_process_handle_for_inspection(
        self,
    ) -> Option<(DiagnosticsGetProcessHandleForInspectionResponder)> {
        if let DiagnosticsRequest::GetProcessHandleForInspection { 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",
            DiagnosticsRequest::GetProcessHandleForInspection { .. } => {
                "get_process_handle_for_inspection"
            }
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> 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,
            0x336c39330bd8e1ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DiagnosticsGetProcessHandleForInspectionResponder {
    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 DiagnosticsGetProcessHandleForInspectionResponder {
    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 DiagnosticsGetProcessHandleForInspectionResponder {
    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 DiagnosticsGetProcessHandleForInspectionResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut process: fdomain_client::Process) -> Result<(), fidl::Error> {
        let _result = self.send_raw(process);
        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 process: fdomain_client::Process,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(process);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut process: fdomain_client::Process) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DiagnosticsGetProcessHandleForInspectionResponse>(
            (process,),
            self.tx_id,
            0x563e5df030f2f4d5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for InterfacesMarker {
    type Proxy = InterfacesProxy;
    type RequestStream = InterfacesRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.debug.Interfaces";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for InterfacesMarker {}
pub type InterfacesCloseBackingSessionResult = Result<(), CloseSessionError>;

pub trait InterfacesProxyInterface: Send + Sync {
    fn r#get_port(
        &self,
        id: u64,
        port: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseBackingSessionResponseFut: std::future::Future<Output = Result<InterfacesCloseBackingSessionResult, fidl::Error>>
        + Send;
    fn r#close_backing_session(&self, id: u64) -> Self::CloseBackingSessionResponseFut;
}

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

impl fdomain_client::fidl::Proxy for InterfacesProxy {
    type Protocol = InterfacesMarker;

    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 InterfacesProxy {
    /// Create a new Proxy for fuchsia.net.debug/Interfaces.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <InterfacesMarker 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) -> InterfacesEventStream {
        InterfacesEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Provides access to the port backing an interface.
    ///
    /// `port` is closed with `ZX_ERR_NOT_FOUND` if an interface referenced by
    /// `id` does not exist or `ZX_ERR_NOT_SUPPORTED` if it is not backed by a
    /// [`fuchsia.hardware.network/Port`].
    ///
    /// + request `id` identifies the interface whose port is granted.
    /// + request `port` grants access to the interface's device port.
    pub fn r#get_port(
        &self,
        mut id: u64,
        mut port: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error> {
        InterfacesProxyInterface::r#get_port(self, id, port)
    }

    /// Closes the session with the network device that backs the interface.
    ///
    /// This method will wait for the backing session to be closed, which will
    /// result in the removal of the interface(s) using that session from the
    /// netstack. This is different from the traditional interface removal with
    /// `fuchsia.net.interfaces.admin.Control` in the sense that the latter
    /// does not close the session.
    ///
    /// + request `id` identifies the interface.
    ///
    /// - error `INTERFACE_NOT_FOUND` if the given `id` is not found.
    /// - error `NOT_SUPPORTED` if the interface is not backed by a network-device
    ///   or if the operation is not supported.
    pub fn r#close_backing_session(
        &self,
        mut id: u64,
    ) -> fidl::client::QueryResponseFut<
        InterfacesCloseBackingSessionResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        InterfacesProxyInterface::r#close_backing_session(self, id)
    }
}

impl InterfacesProxyInterface for InterfacesProxy {
    fn r#get_port(
        &self,
        mut id: u64,
        mut port: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<InterfacesGetPortRequest>(
            (id, port),
            0xdd15c4df17fb148,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseBackingSessionResponseFut = fidl::client::QueryResponseFut<
        InterfacesCloseBackingSessionResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#close_backing_session(&self, mut id: u64) -> Self::CloseBackingSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InterfacesCloseBackingSessionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, CloseSessionError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x57da4d8a53ac6d0c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            InterfacesCloseBackingSessionRequest,
            InterfacesCloseBackingSessionResult,
        >(
            (id,),
            0x57da4d8a53ac6d0c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.debug/Interfaces.
pub struct InterfacesRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for InterfacesRequestStream {
    type Protocol = InterfacesMarker;
    type ControlHandle = InterfacesControlHandle;

    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 {
        InterfacesControlHandle { 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 InterfacesRequestStream {
    type Item = Result<InterfacesRequest, 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 InterfacesRequestStream 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 {
                    0xdd15c4df17fb148 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            InterfacesGetPortRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<InterfacesGetPortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = InterfacesControlHandle { inner: this.inner.clone() };
                        Ok(InterfacesRequest::GetPort {
                            id: req.id,
                            port: req.port,

                            control_handle,
                        })
                    }
                    0x57da4d8a53ac6d0c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            InterfacesCloseBackingSessionRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<InterfacesCloseBackingSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = InterfacesControlHandle { inner: this.inner.clone() };
                        Ok(InterfacesRequest::CloseBackingSession {
                            id: req.id,

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

/// Network interface debugging functionality.
///
/// This protocol is intended for debugging and testing only; and not meant for
/// load-bearing code.
#[derive(Debug)]
pub enum InterfacesRequest {
    /// Provides access to the port backing an interface.
    ///
    /// `port` is closed with `ZX_ERR_NOT_FOUND` if an interface referenced by
    /// `id` does not exist or `ZX_ERR_NOT_SUPPORTED` if it is not backed by a
    /// [`fuchsia.hardware.network/Port`].
    ///
    /// + request `id` identifies the interface whose port is granted.
    /// + request `port` grants access to the interface's device port.
    GetPort {
        id: u64,
        port: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_hardware_network::PortMarker>,
        control_handle: InterfacesControlHandle,
    },
    /// Closes the session with the network device that backs the interface.
    ///
    /// This method will wait for the backing session to be closed, which will
    /// result in the removal of the interface(s) using that session from the
    /// netstack. This is different from the traditional interface removal with
    /// `fuchsia.net.interfaces.admin.Control` in the sense that the latter
    /// does not close the session.
    ///
    /// + request `id` identifies the interface.
    ///
    /// - error `INTERFACE_NOT_FOUND` if the given `id` is not found.
    /// - error `NOT_SUPPORTED` if the interface is not backed by a network-device
    ///   or if the operation is not supported.
    CloseBackingSession { id: u64, responder: InterfacesCloseBackingSessionResponder },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_close_backing_session(
        self,
    ) -> Option<(u64, InterfacesCloseBackingSessionResponder)> {
        if let InterfacesRequest::CloseBackingSession { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            InterfacesRequest::GetPort { .. } => "get_port",
            InterfacesRequest::CloseBackingSession { .. } => "close_backing_session",
        }
    }
}

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

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

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

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

impl InterfacesControlHandle {}

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for PacketCaptureProviderMarker {
    type Proxy = PacketCaptureProviderProxy;
    type RequestStream = PacketCaptureProviderRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.debug.PacketCaptureProvider";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for PacketCaptureProviderMarker {}
pub type PacketCaptureProviderStartRollingResult =
    Result<fdomain_client::fidl::ClientEnd<RollingPacketCaptureMarker>, PacketCaptureStartError>;
pub type PacketCaptureProviderReconnectRollingResult = Result<
    fdomain_client::fidl::ClientEnd<RollingPacketCaptureMarker>,
    PacketCaptureReconnectError,
>;

pub trait PacketCaptureProviderProxyInterface: Send + Sync {
    type StartRollingResponseFut: std::future::Future<Output = Result<PacketCaptureProviderStartRollingResult, fidl::Error>>
        + Send;
    fn r#start_rolling(
        &self,
        common_params: CommonPacketCaptureParams,
        params: &RollingPacketCaptureParams,
    ) -> Self::StartRollingResponseFut;
    type ReconnectRollingResponseFut: std::future::Future<
            Output = Result<PacketCaptureProviderReconnectRollingResult, fidl::Error>,
        > + Send;
    fn r#reconnect_rolling(&self, name: &str) -> Self::ReconnectRollingResponseFut;
}

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

impl fdomain_client::fidl::Proxy for PacketCaptureProviderProxy {
    type Protocol = PacketCaptureProviderMarker;

    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 PacketCaptureProviderProxy {
    /// Create a new Proxy for fuchsia.net.debug/PacketCaptureProvider.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <PacketCaptureProviderMarker 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) -> PacketCaptureProviderEventStream {
        PacketCaptureProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Start a rolling packet capture.
    ///
    /// Lifetime of the packet capture is tied to the pipelined `channel` unless
    /// [`RollingPacketCapture.Detach`] has been called.
    ///
    /// ## Error
    ///
    /// All variants of [`PacketCaptureStartError`] may be returned by this
    /// method.
    pub fn r#start_rolling(
        &self,
        mut common_params: CommonPacketCaptureParams,
        mut params: &RollingPacketCaptureParams,
    ) -> fidl::client::QueryResponseFut<
        PacketCaptureProviderStartRollingResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketCaptureProviderProxyInterface::r#start_rolling(self, common_params, params)
    }

    /// Reconnects to a packet capture previously started with
    /// [`PacketCaptureProvider/StartRolling`].
    ///
    /// If another channel is already connected to the packet capture, it will be
    /// closed to make room for this connection.
    ///
    /// Note reconnecting does not reattach the lifetime of the packet capture to
    /// `channel`.
    pub fn r#reconnect_rolling(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        PacketCaptureProviderReconnectRollingResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketCaptureProviderProxyInterface::r#reconnect_rolling(self, name)
    }
}

impl PacketCaptureProviderProxyInterface for PacketCaptureProviderProxy {
    type StartRollingResponseFut = fidl::client::QueryResponseFut<
        PacketCaptureProviderStartRollingResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#start_rolling(
        &self,
        mut common_params: CommonPacketCaptureParams,
        mut params: &RollingPacketCaptureParams,
    ) -> Self::StartRollingResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketCaptureProviderStartRollingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    PacketCaptureProviderStartRollingResponse,
                    PacketCaptureStartError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4a5b2305ea27e845,
            >(_buf?)?;
            Ok(_response.map(|x| x.channel))
        }
        self.client.send_query_and_decode::<
            PacketCaptureProviderStartRollingRequest,
            PacketCaptureProviderStartRollingResult,
        >(
            (&mut common_params, params,),
            0x4a5b2305ea27e845,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReconnectRollingResponseFut = fidl::client::QueryResponseFut<
        PacketCaptureProviderReconnectRollingResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#reconnect_rolling(&self, mut name: &str) -> Self::ReconnectRollingResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketCaptureProviderReconnectRollingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    PacketCaptureProviderReconnectRollingResponse,
                    PacketCaptureReconnectError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x57828e9ed034a522,
            >(_buf?)?;
            Ok(_response.map(|x| x.channel))
        }
        self.client.send_query_and_decode::<
            PacketCaptureProviderReconnectRollingRequest,
            PacketCaptureProviderReconnectRollingResult,
        >(
            (name,),
            0x57828e9ed034a522,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.debug/PacketCaptureProvider.
pub struct PacketCaptureProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for PacketCaptureProviderRequestStream {
    type Protocol = PacketCaptureProviderMarker;
    type ControlHandle = PacketCaptureProviderControlHandle;

    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 {
        PacketCaptureProviderControlHandle { 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 PacketCaptureProviderRequestStream {
    type Item = Result<PacketCaptureProviderRequest, 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 PacketCaptureProviderRequestStream 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 {
                0x4a5b2305ea27e845 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PacketCaptureProviderStartRollingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PacketCaptureProviderStartRollingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketCaptureProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketCaptureProviderRequest::StartRolling {common_params: req.common_params,
params: req.params,

                        responder: PacketCaptureProviderStartRollingResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x57828e9ed034a522 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PacketCaptureProviderReconnectRollingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PacketCaptureProviderReconnectRollingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketCaptureProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketCaptureProviderRequest::ReconnectRolling {name: req.name,

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

/// Provides packet captures.
///
/// [`PacketCaptureProvider.StartRolling`] is recommended if:
/// 1. You need resilience against network interruptions closing the channel
///    tied to the packet capture’s lifetime.
/// 2. You know when the packets of interest get captured, e.g. when a specific
///    networking event you’re looking for occurs.
/// 3. Not having to continuously read packet capture data from the Netstack
///    is a benefit.
///
/// Note that in order to conserve memory, the server maintains a limit on the
/// number of concurrent packet captures, and starting another packet capture
/// when the quota has been met fails.
///
/// In all cases, the server sends the packet captures in [pcapng format],
/// i.e. there is a Section Header Block at the start of each packet capture
/// followed by one or more Interface Description Blocks, followed by Enhanced
/// Packet Blocks containing packet data. Other blocks defined by the pcapng
/// file standard may appear as well.
///
/// [pcapng format]: https://www.ietf.org/archive/id/draft-ietf-opsawg-pcapng-05.html
#[derive(Debug)]
pub enum PacketCaptureProviderRequest {
    /// Start a rolling packet capture.
    ///
    /// Lifetime of the packet capture is tied to the pipelined `channel` unless
    /// [`RollingPacketCapture.Detach`] has been called.
    ///
    /// ## Error
    ///
    /// All variants of [`PacketCaptureStartError`] may be returned by this
    /// method.
    StartRolling {
        common_params: CommonPacketCaptureParams,
        params: RollingPacketCaptureParams,
        responder: PacketCaptureProviderStartRollingResponder,
    },
    /// Reconnects to a packet capture previously started with
    /// [`PacketCaptureProvider/StartRolling`].
    ///
    /// If another channel is already connected to the packet capture, it will be
    /// closed to make room for this connection.
    ///
    /// Note reconnecting does not reattach the lifetime of the packet capture to
    /// `channel`.
    ReconnectRolling { name: String, responder: PacketCaptureProviderReconnectRollingResponder },
}

impl PacketCaptureProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_rolling(
        self,
    ) -> Option<(
        CommonPacketCaptureParams,
        RollingPacketCaptureParams,
        PacketCaptureProviderStartRollingResponder,
    )> {
        if let PacketCaptureProviderRequest::StartRolling { common_params, params, responder } =
            self
        {
            Some((common_params, params, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reconnect_rolling(
        self,
    ) -> Option<(String, PacketCaptureProviderReconnectRollingResponder)> {
        if let PacketCaptureProviderRequest::ReconnectRolling { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PacketCaptureProviderRequest::StartRolling { .. } => "start_rolling",
            PacketCaptureProviderRequest::ReconnectRolling { .. } => "reconnect_rolling",
        }
    }
}

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

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

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

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

impl PacketCaptureProviderControlHandle {}

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

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

    fn control_handle(&self) -> &PacketCaptureProviderControlHandle {
        &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 PacketCaptureProviderStartRollingResponder {
    /// 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<RollingPacketCaptureMarker>,
            PacketCaptureStartError,
        >,
    ) -> 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<RollingPacketCaptureMarker>,
            PacketCaptureStartError,
        >,
    ) -> 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<RollingPacketCaptureMarker>,
            PacketCaptureStartError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            PacketCaptureProviderStartRollingResponse,
            PacketCaptureStartError,
        >>(
            result.map(|channel| (channel,)),
            self.tx_id,
            0x4a5b2305ea27e845,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &PacketCaptureProviderControlHandle {
        &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 PacketCaptureProviderReconnectRollingResponder {
    /// 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<RollingPacketCaptureMarker>,
            PacketCaptureReconnectError,
        >,
    ) -> 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<RollingPacketCaptureMarker>,
            PacketCaptureReconnectError,
        >,
    ) -> 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<RollingPacketCaptureMarker>,
            PacketCaptureReconnectError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            PacketCaptureProviderReconnectRollingResponse,
            PacketCaptureReconnectError,
        >>(
            result.map(|channel| (channel,)),
            self.tx_id,
            0x57828e9ed034a522,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RollingPacketCaptureMarker {
    type Proxy = RollingPacketCaptureProxy;
    type RequestStream = RollingPacketCaptureRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RollingPacketCapture";
}
pub type RollingPacketCaptureDetachResult = Result<(), RollingPacketCaptureDetachError>;

pub trait RollingPacketCaptureProxyInterface: Send + Sync {
    type DetachResponseFut: std::future::Future<Output = Result<RollingPacketCaptureDetachResult, fidl::Error>>
        + Send;
    fn r#detach(&self, name: &str) -> Self::DetachResponseFut;
    fn r#stop_and_download(
        &self,
        channel: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
    ) -> Result<(), fidl::Error>;
    type DiscardResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard(&self) -> Self::DiscardResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RollingPacketCaptureProxy {
    type Protocol = RollingPacketCaptureMarker;

    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 RollingPacketCaptureProxy {
    /// Create a new Proxy for fuchsia.net.debug/RollingPacketCapture.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <RollingPacketCaptureMarker 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) -> RollingPacketCaptureEventStream {
        RollingPacketCaptureEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Detaches the lifetime of this protocol from the underlying packet
    /// capture.
    ///
    /// After calling `Detach`, closing the client end no longer results in
    /// the packet capture from being terminated. The passed string names
    /// this packet capture and can be used thereafter to reconnect via
    /// [`PacketCaptureProvider.ReconnectRolling`]. The protocol is still
    /// detached after reconnecting. This gives the client the option of
    /// ensuring the packet capture is resilient against disconnections.
    ///
    /// Only the first call to `Detach` over the lifetime of the packet
    /// capture (note this is different from the lifetime of this protocol
    /// since it's possible to disconnect and reconnect) is valid. Subsequent
    /// calls cannot change the name of this capture.
    ///
    /// Once this method returns, it is guaranteed that this rolling packet
    /// capture is detached.
    pub fn r#detach(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        RollingPacketCaptureDetachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RollingPacketCaptureProxyInterface::r#detach(self, name)
    }

    /// Stop and make this rolling packet capture downloadable.
    ///
    /// It is implicit by calling this method that the packet capture is stopped
    /// due to user request, so the [`RollingPacketCapture.OnEnded`] event is
    /// not emitted.
    ///
    /// This method can be called multiple times, including across disconnects:
    /// a client can call this method, disconnect, reconnect, and call this
    /// method again.
    ///
    /// The server discards the contents of the packet capture once this
    /// method has been called and there is no client connected to this protocol
    /// for some time.
    pub fn r#stop_and_download(
        &self,
        mut channel: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
    ) -> Result<(), fidl::Error> {
        RollingPacketCaptureProxyInterface::r#stop_and_download(self, channel)
    }

    /// Discard this rolling packet capture.
    ///
    /// Clients should call this method when they have successfully downloaded
    /// the packet capture, or if they no longer need it for any reason.
    ///
    /// The server closes all readers initialized via [`StopAndDownload`]
    /// and all future interactions on this protocol are invalid. When this
    /// method returns, it is guaranteed that the packet capture has been
    /// discarded and the usage quota has been released.
    pub fn r#discard(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        RollingPacketCaptureProxyInterface::r#discard(self)
    }
}

impl RollingPacketCaptureProxyInterface for RollingPacketCaptureProxy {
    type DetachResponseFut = fidl::client::QueryResponseFut<
        RollingPacketCaptureDetachResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#detach(&self, mut name: &str) -> Self::DetachResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RollingPacketCaptureDetachResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    RollingPacketCaptureDetachError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0xb3d28b9518e7db0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RollingPacketCaptureDetachRequest,
            RollingPacketCaptureDetachResult,
        >(
            (name,),
            0xb3d28b9518e7db0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#stop_and_download(
        &self,
        mut channel: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RollingPacketCaptureStopAndDownloadRequest>(
            (channel,),
            0x268270260a49e2ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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

#[derive(Debug)]
pub enum RollingPacketCaptureEvent {
    OnEnded { reason: PacketCaptureEndReason },
}

impl RollingPacketCaptureEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_ended(self) -> Option<PacketCaptureEndReason> {
        if let RollingPacketCaptureEvent::OnEnded { reason } = self { Some((reason)) } else { None }
    }

    /// Decodes a message buffer as a [`RollingPacketCaptureEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RollingPacketCaptureEvent, 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 {
            0x74690c9d4f59f506 => {
                let mut out = fidl::new_empty!(
                    RollingPacketCaptureOnEndedRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RollingPacketCaptureOnEndedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RollingPacketCaptureEvent::OnEnded { reason: out.reason }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <RollingPacketCaptureMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.net.debug/RollingPacketCapture.
pub struct RollingPacketCaptureRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RollingPacketCaptureRequestStream {
    type Protocol = RollingPacketCaptureMarker;
    type ControlHandle = RollingPacketCaptureControlHandle;

    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 {
        RollingPacketCaptureControlHandle { 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 RollingPacketCaptureRequestStream {
    type Item = Result<RollingPacketCaptureRequest, 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 RollingPacketCaptureRequestStream 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 {
                0xb3d28b9518e7db0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RollingPacketCaptureDetachRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RollingPacketCaptureDetachRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RollingPacketCaptureControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RollingPacketCaptureRequest::Detach {name: req.name,

                        responder: RollingPacketCaptureDetachResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x268270260a49e2ea => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(RollingPacketCaptureStopAndDownloadRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RollingPacketCaptureStopAndDownloadRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RollingPacketCaptureControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RollingPacketCaptureRequest::StopAndDownload {channel: req.channel,

                        control_handle,
                    })
                }
                0x89e60c428d47a1 => {
                    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 = RollingPacketCaptureControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RollingPacketCaptureRequest::Discard {
                        responder: RollingPacketCaptureDiscardResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <RollingPacketCaptureMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Rolling packet capture.
///
/// Once a rolling packet capture has stopped either because [`StopAndDownload`]
/// has been called or the capture stopped for some other reason and the server
/// has emitted [`OnEnded`], and there is no client connected to this protocol
/// for some time, the server discards the contents of the packet capture.
/// This timeout resets every time a client reconnects to this protocol, and
/// exists to provide resilience against disconnections.
#[derive(Debug)]
pub enum RollingPacketCaptureRequest {
    /// Detaches the lifetime of this protocol from the underlying packet
    /// capture.
    ///
    /// After calling `Detach`, closing the client end no longer results in
    /// the packet capture from being terminated. The passed string names
    /// this packet capture and can be used thereafter to reconnect via
    /// [`PacketCaptureProvider.ReconnectRolling`]. The protocol is still
    /// detached after reconnecting. This gives the client the option of
    /// ensuring the packet capture is resilient against disconnections.
    ///
    /// Only the first call to `Detach` over the lifetime of the packet
    /// capture (note this is different from the lifetime of this protocol
    /// since it's possible to disconnect and reconnect) is valid. Subsequent
    /// calls cannot change the name of this capture.
    ///
    /// Once this method returns, it is guaranteed that this rolling packet
    /// capture is detached.
    Detach { name: String, responder: RollingPacketCaptureDetachResponder },
    /// Stop and make this rolling packet capture downloadable.
    ///
    /// It is implicit by calling this method that the packet capture is stopped
    /// due to user request, so the [`RollingPacketCapture.OnEnded`] event is
    /// not emitted.
    ///
    /// This method can be called multiple times, including across disconnects:
    /// a client can call this method, disconnect, reconnect, and call this
    /// method again.
    ///
    /// The server discards the contents of the packet capture once this
    /// method has been called and there is no client connected to this protocol
    /// for some time.
    StopAndDownload {
        channel: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
        control_handle: RollingPacketCaptureControlHandle,
    },
    /// Discard this rolling packet capture.
    ///
    /// Clients should call this method when they have successfully downloaded
    /// the packet capture, or if they no longer need it for any reason.
    ///
    /// The server closes all readers initialized via [`StopAndDownload`]
    /// and all future interactions on this protocol are invalid. When this
    /// method returns, it is guaranteed that the packet capture has been
    /// discarded and the usage quota has been released.
    Discard { responder: RollingPacketCaptureDiscardResponder },
}

impl RollingPacketCaptureRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_detach(self) -> Option<(String, RollingPacketCaptureDetachResponder)> {
        if let RollingPacketCaptureRequest::Detach { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_and_download(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::FileMarker>,
        RollingPacketCaptureControlHandle,
    )> {
        if let RollingPacketCaptureRequest::StopAndDownload { channel, control_handle } = self {
            Some((channel, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard(self) -> Option<(RollingPacketCaptureDiscardResponder)> {
        if let RollingPacketCaptureRequest::Discard { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RollingPacketCaptureRequest::Detach { .. } => "detach",
            RollingPacketCaptureRequest::StopAndDownload { .. } => "stop_and_download",
            RollingPacketCaptureRequest::Discard { .. } => "discard",
        }
    }
}

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

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

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

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

impl RollingPacketCaptureControlHandle {
    pub fn send_on_ended(&self, mut reason: PacketCaptureEndReason) -> Result<(), fidl::Error> {
        self.inner.send::<RollingPacketCaptureOnEndedRequest>(
            (reason,),
            0,
            0x74690c9d4f59f506,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DiagnosticsGetProcessHandleForInspectionResponse {
        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 DiagnosticsGetProcessHandleForInspectionResponse {
        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<
            DiagnosticsGetProcessHandleForInspectionResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DiagnosticsGetProcessHandleForInspectionResponse
    {
        #[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::<DiagnosticsGetProcessHandleForInspectionResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DiagnosticsGetProcessHandleForInspectionResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    32768,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.process
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    32768,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DiagnosticsGetProcessHandleForInspectionResponse,
            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::<DiagnosticsGetProcessHandleForInspectionResponse>(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 DiagnosticsGetProcessHandleForInspectionResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                process: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 32768>, 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::Process, { fidl::ObjectType::PROCESS.into_raw() }, 32768>, fdomain_client::fidl::FDomainResourceDialect, &mut self.process, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for InterfacesGetPortRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                port: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_hardware_network::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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_hardware_network::PortMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.port,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for PacketCaptureProviderStartRollingRequest {
        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 PacketCaptureProviderStartRollingRequest {
        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<
            PacketCaptureProviderStartRollingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PacketCaptureProviderStartRollingRequest
    {
        #[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::<PacketCaptureProviderStartRollingRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PacketCaptureProviderStartRollingRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <CommonPacketCaptureParams as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.common_params),
                    <RollingPacketCaptureParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                CommonPacketCaptureParams,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                RollingPacketCaptureParams,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PacketCaptureProviderStartRollingRequest,
            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::<PacketCaptureProviderStartRollingRequest>(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 PacketCaptureProviderStartRollingRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                common_params: fidl::new_empty!(
                    CommonPacketCaptureParams,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                params: fidl::new_empty!(
                    RollingPacketCaptureParams,
                    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!(
                CommonPacketCaptureParams,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.common_params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                RollingPacketCaptureParams,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.params,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    impl CommonPacketCaptureParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.snap_len {
                return 3;
            }
            if let Some(_) = self.bpf_program {
                return 2;
            }
            if let Some(_) = self.interfaces {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CommonPacketCaptureParams {
        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 CommonPacketCaptureParams {
        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<
            CommonPacketCaptureParams,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CommonPacketCaptureParams
    {
        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::<CommonPacketCaptureParams>(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::<
                InterfaceSpecifier,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.interfaces
                    .as_ref()
                    .map(<InterfaceSpecifier 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::<fdomain_fuchsia_ebpf::VerifiedProgram, fdomain_client::fidl::FDomainResourceDialect>(
            self.bpf_program.as_mut().map(<fdomain_fuchsia_ebpf::VerifiedProgram 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::<
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.snap_len.as_ref().map(<u32 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 CommonPacketCaptureParams
    {
        #[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 =
                    <InterfaceSpecifier 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.interfaces.get_or_insert_with(|| {
                    fidl::new_empty!(
                        InterfaceSpecifier,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    InterfaceSpecifier,
                    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 = <fdomain_fuchsia_ebpf::VerifiedProgram 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.bpf_program.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fdomain_fuchsia_ebpf::VerifiedProgram,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fdomain_fuchsia_ebpf::VerifiedProgram,
                    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 =
                    <u32 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.snap_len.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u32,
                    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(())
        }
    }
}