fidl_fuchsia_diagnostics/

fidl_fuchsia_diagnostics.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_diagnostics__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, PartialEq)]
pub struct ArchiveAccessorStreamDiagnosticsRequest {
    pub stream_parameters: StreamParameters,
    pub result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct BatchIteratorGetNextResponse {
    pub batch: Vec<FormattedContent>,
}

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

#[derive(Debug, PartialEq)]
pub struct LogStreamConnectRequest {
    pub socket: fidl::Socket,
    pub opts: LogStreamOptions,
}

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

/// A fidl union containing a complete hierarchy of structured diagnostics
/// data, such that the content can be parsed into a file by itself.
#[derive(Debug)]
pub enum FormattedContent {
    /// A diagnostics schema encoded as json.
    /// The VMO will contain up to 1mb of diagnostics data.
    Json(fidl_fuchsia_mem::Buffer),
    /// A diagnostics schema encoded as text.
    /// The VMO will contain up to 1mb of diagnostics data.
    Text(fidl_fuchsia_mem::Buffer),
    /// A diagnostics schema encoded as cbor.
    /// The VMO will contain up to 1mb of diagnostics data.
    /// The size will be in ZX_PROP_VMO_CONTENT_SIZE.
    Cbor(fidl::Vmo),
    /// A diagnostics schema encoded as FXT.
    /// This is only valid for logs data.
    /// The VMO will contain up to PerformanceConfiguration/max_aggregate_content_size_bytes
    /// of diagnostics data, or 1mb if not specified.
    /// The size will be in ZX_PROP_VMO_CONTENT_SIZE.
    Fxt(fidl::Vmo),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

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

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

impl FormattedContent {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Json(_) => 1,
            Self::Text(_) => 2,
            Self::Cbor(_) => 3,
            Self::Fxt(_) => 4,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ArchiveAccessorMarker {
    type Proxy = ArchiveAccessorProxy;
    type RequestStream = ArchiveAccessorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ArchiveAccessorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.ArchiveAccessor";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ArchiveAccessorMarker {}

pub trait ArchiveAccessorProxyInterface: Send + Sync {
    fn r#stream_diagnostics(
        &self,
        stream_parameters: &StreamParameters,
        result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type WaitForReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ArchiveAccessorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ArchiveAccessorSynchronousProxy {
    type Proxy = ArchiveAccessorProxy;
    type Protocol = ArchiveAccessorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ArchiveAccessorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Creates an iterator over diagnostics data on the system.
    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
    ///     current state of diagnostics data on the system.
    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
    ///     data.
    ///
    /// + request `result stream` a [fuchsia.diagnostics/BatchIterator] that diagnostic
    ///   records are exposed to the client over.
    ///   * epitaphs:
    ///      - INVALID_ARGS: A required argument in the StreamParameters struct was missing.
    ///      - WRONG_TYPE: A selector provided by the StreamParameters struct was incorrectly
    ///                    formatted.
    ///
    /// + request `stream_parameters` is a [fuchsia.diagnostics/StreamParameter] which
    ///   specifies how to configure the stream.
    pub fn r#stream_diagnostics(
        &self,
        mut stream_parameters: &StreamParameters,
        mut result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ArchiveAccessorStreamDiagnosticsRequest>(
            (stream_parameters, result_stream),
            0x20c73e2ecd653c3e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Ensures that the connection with the server was established to prevent
    /// races when using other pipelined methods of this protocol.
    pub fn r#wait_for_ready(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (),
            0x122963198011bd24,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ArchiveAccessorMarker>("wait_for_ready")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ArchiveAccessorProxy {
    type Protocol = ArchiveAccessorMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ArchiveAccessorProxy {
    /// Create a new Proxy for fuchsia.diagnostics/ArchiveAccessor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ArchiveAccessorEventStream {
        ArchiveAccessorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates an iterator over diagnostics data on the system.
    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
    ///     current state of diagnostics data on the system.
    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
    ///     data.
    ///
    /// + request `result stream` a [fuchsia.diagnostics/BatchIterator] that diagnostic
    ///   records are exposed to the client over.
    ///   * epitaphs:
    ///      - INVALID_ARGS: A required argument in the StreamParameters struct was missing.
    ///      - WRONG_TYPE: A selector provided by the StreamParameters struct was incorrectly
    ///                    formatted.
    ///
    /// + request `stream_parameters` is a [fuchsia.diagnostics/StreamParameter] which
    ///   specifies how to configure the stream.
    pub fn r#stream_diagnostics(
        &self,
        mut stream_parameters: &StreamParameters,
        mut result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        ArchiveAccessorProxyInterface::r#stream_diagnostics(self, stream_parameters, result_stream)
    }

    /// Ensures that the connection with the server was established to prevent
    /// races when using other pipelined methods of this protocol.
    pub fn r#wait_for_ready(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ArchiveAccessorProxyInterface::r#wait_for_ready(self)
    }
}

impl ArchiveAccessorProxyInterface for ArchiveAccessorProxy {
    fn r#stream_diagnostics(
        &self,
        mut stream_parameters: &StreamParameters,
        mut result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ArchiveAccessorStreamDiagnosticsRequest>(
            (stream_parameters, result_stream),
            0x20c73e2ecd653c3e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type WaitForReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x122963198011bd24,
            >(_buf?)?
            .into_result::<ArchiveAccessorMarker>("wait_for_ready")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x122963198011bd24,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl ArchiveAccessorEvent {
    /// Decodes a message buffer as a [`ArchiveAccessorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ArchiveAccessorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ArchiveAccessorEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for ArchiveAccessorRequestStream {
    type Protocol = ArchiveAccessorMarker;
    type ControlHandle = ArchiveAccessorControlHandle;

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

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

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

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

impl futures::Stream for ArchiveAccessorRequestStream {
    type Item = Result<ArchiveAccessorRequest, 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 ArchiveAccessorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20c73e2ecd653c3e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ArchiveAccessorStreamDiagnosticsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ArchiveAccessorStreamDiagnosticsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ArchiveAccessorControlHandle { inner: this.inner.clone() };
                        Ok(ArchiveAccessorRequest::StreamDiagnostics {
                            stream_parameters: req.stream_parameters,
                            result_stream: req.result_stream,

                            control_handle,
                        })
                    }
                    0x122963198011bd24 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ArchiveAccessorControlHandle { inner: this.inner.clone() };
                        Ok(ArchiveAccessorRequest::WaitForReady {
                            responder: ArchiveAccessorWaitForReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(ArchiveAccessorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ArchiveAccessorControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(ArchiveAccessorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ArchiveAccessorControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ArchiveAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Outer protocol for interacting with the different diagnostics data sources.
#[derive(Debug)]
pub enum ArchiveAccessorRequest {
    /// Creates an iterator over diagnostics data on the system.
    ///   * The iterator may be finite by streaming in SNAPSHOT mode, serving only the
    ///     current state of diagnostics data on the system.
    ///   * The iterator may be infinite by streaming in either SNAPSHOT_THEN_SUBSCRIBE
    ///     or SUBSCRIBE mode; the prior first provides iteration over the current state of
    ///     the sytem, and then both provide ongoing iteration over newly arriving diagnostics
    ///     data.
    ///
    /// + request `result stream` a [fuchsia.diagnostics/BatchIterator] that diagnostic
    ///   records are exposed to the client over.
    ///   * epitaphs:
    ///      - INVALID_ARGS: A required argument in the StreamParameters struct was missing.
    ///      - WRONG_TYPE: A selector provided by the StreamParameters struct was incorrectly
    ///                    formatted.
    ///
    /// + request `stream_parameters` is a [fuchsia.diagnostics/StreamParameter] which
    ///   specifies how to configure the stream.
    StreamDiagnostics {
        stream_parameters: StreamParameters,
        result_stream: fidl::endpoints::ServerEnd<BatchIteratorMarker>,
        control_handle: ArchiveAccessorControlHandle,
    },
    /// Ensures that the connection with the server was established to prevent
    /// races when using other pipelined methods of this protocol.
    WaitForReady { responder: ArchiveAccessorWaitForReadyResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: ArchiveAccessorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ArchiveAccessorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_stream_diagnostics(
        self,
    ) -> Option<(
        StreamParameters,
        fidl::endpoints::ServerEnd<BatchIteratorMarker>,
        ArchiveAccessorControlHandle,
    )> {
        if let ArchiveAccessorRequest::StreamDiagnostics {
            stream_parameters,
            result_stream,
            control_handle,
        } = self
        {
            Some((stream_parameters, result_stream, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_ready(self) -> Option<(ArchiveAccessorWaitForReadyResponder)> {
        if let ArchiveAccessorRequest::WaitForReady { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ArchiveAccessorRequest::StreamDiagnostics { .. } => "stream_diagnostics",
            ArchiveAccessorRequest::WaitForReady { .. } => "wait_for_ready",
            ArchiveAccessorRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            ArchiveAccessorRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ArchiveAccessorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl ArchiveAccessorControlHandle {}

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

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

impl fidl::endpoints::Responder for ArchiveAccessorWaitForReadyResponder {
    type ControlHandle = ArchiveAccessorControlHandle;

    fn control_handle(&self) -> &ArchiveAccessorControlHandle {
        &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 ArchiveAccessorWaitForReadyResponder {
    /// 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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x122963198011bd24,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BatchIteratorMarker {
    type Proxy = BatchIteratorProxy;
    type RequestStream = BatchIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BatchIteratorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BatchIterator";
}
pub type BatchIteratorGetNextResult = Result<Vec<FormattedContent>, ReaderError>;

pub trait BatchIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<BatchIteratorGetNextResult, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
    type WaitForReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BatchIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BatchIteratorSynchronousProxy {
    type Proxy = BatchIteratorProxy;
    type Protocol = BatchIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl BatchIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <BatchIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Returns a vector of [fuchsia.diagnostics/FormattedContent] structs
    /// with a format dictated by the format_settings argument provided to the Reader protocol
    /// which spawned this BatchIterator.
    ///
    /// An empty vector implies that the data hierarchy has been fully iterated, and subsequent
    /// GetNext calls will always return the empty vector.
    ///
    /// When the BatchIterator is serving results via subscription model, calls to GetNext will
    /// hang until there is new data available, it will not return an empty vector.
    ///
    /// - returns a vector of FormattedContent structs. Clients connected to a
    ///   Batch are expected to call GetNext() until an empty vector
    ///   is returned, denoting that the entire data hierarchy has been read.
    ///
    /// * error a [fuchsia.diagnostics/ReaderError]
    ///   value indicating that there was an issue reading the underlying data hierarchies
    ///   or formatting those hierarchies to populate the `batch`. Note, these
    ///   issues do not include a single component's data hierarchy failing to be read.
    ///   The iterator is tolerant of individual component data sources failing to be read,
    ///   whether that failure is a timeout or a malformed binary file.
    ///   In the event that a GetNext call fails, that subset of the data hierarchy results is
    ///   dropped, but future calls to GetNext will provide new subsets of
    ///   FormattedDataHierarchies.
    pub fn r#get_next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BatchIteratorGetNextResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<BatchIteratorGetNextResponse, ReaderError>,
        >(
            (),
            0x781986486c6254a5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<BatchIteratorMarker>("get_next")?;
        Ok(_response.map(|x| x.batch))
    }

    /// Indiciates that the BatchIterator has been connected. If the
    /// BatchIterator hasn't been connected, this method will hang until it is.
    pub fn r#wait_for_ready(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (),
            0x70598ee271597603,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<BatchIteratorMarker>("wait_for_ready")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BatchIteratorProxy {
    type Protocol = BatchIteratorMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl BatchIteratorProxy {
    /// Create a new Proxy for fuchsia.diagnostics/BatchIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BatchIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BatchIteratorEventStream {
        BatchIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a vector of [fuchsia.diagnostics/FormattedContent] structs
    /// with a format dictated by the format_settings argument provided to the Reader protocol
    /// which spawned this BatchIterator.
    ///
    /// An empty vector implies that the data hierarchy has been fully iterated, and subsequent
    /// GetNext calls will always return the empty vector.
    ///
    /// When the BatchIterator is serving results via subscription model, calls to GetNext will
    /// hang until there is new data available, it will not return an empty vector.
    ///
    /// - returns a vector of FormattedContent structs. Clients connected to a
    ///   Batch are expected to call GetNext() until an empty vector
    ///   is returned, denoting that the entire data hierarchy has been read.
    ///
    /// * error a [fuchsia.diagnostics/ReaderError]
    ///   value indicating that there was an issue reading the underlying data hierarchies
    ///   or formatting those hierarchies to populate the `batch`. Note, these
    ///   issues do not include a single component's data hierarchy failing to be read.
    ///   The iterator is tolerant of individual component data sources failing to be read,
    ///   whether that failure is a timeout or a malformed binary file.
    ///   In the event that a GetNext call fails, that subset of the data hierarchy results is
    ///   dropped, but future calls to GetNext will provide new subsets of
    ///   FormattedDataHierarchies.
    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BatchIteratorGetNextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BatchIteratorProxyInterface::r#get_next(self)
    }

    /// Indiciates that the BatchIterator has been connected. If the
    /// BatchIterator hasn't been connected, this method will hang until it is.
    pub fn r#wait_for_ready(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        BatchIteratorProxyInterface::r#wait_for_ready(self)
    }
}

impl BatchIteratorProxyInterface for BatchIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        BatchIteratorGetNextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BatchIteratorGetNextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<BatchIteratorGetNextResponse, ReaderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x781986486c6254a5,
            >(_buf?)?
            .into_result::<BatchIteratorMarker>("get_next")?;
            Ok(_response.map(|x| x.batch))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BatchIteratorGetNextResult>(
                (),
                0x781986486c6254a5,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type WaitForReadyResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x70598ee271597603,
            >(_buf?)?
            .into_result::<BatchIteratorMarker>("wait_for_ready")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x70598ee271597603,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl BatchIteratorEvent {
    /// Decodes a message buffer as a [`BatchIteratorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BatchIteratorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(BatchIteratorEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <BatchIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for BatchIteratorRequestStream {
    type Protocol = BatchIteratorMarker;
    type ControlHandle = BatchIteratorControlHandle;

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

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

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

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

impl futures::Stream for BatchIteratorRequestStream {
    type Item = Result<BatchIteratorRequest, 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 BatchIteratorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x781986486c6254a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BatchIteratorControlHandle { inner: this.inner.clone() };
                        Ok(BatchIteratorRequest::GetNext {
                            responder: BatchIteratorGetNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x70598ee271597603 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BatchIteratorControlHandle { inner: this.inner.clone() };
                        Ok(BatchIteratorRequest::WaitForReady {
                            responder: BatchIteratorWaitForReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(BatchIteratorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: BatchIteratorControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(BatchIteratorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: BatchIteratorControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BatchIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Conceptually, a directory iterator, where each element in the iterator is a single
/// complete file that can be concatenated with other results.
#[derive(Debug)]
pub enum BatchIteratorRequest {
    /// Returns a vector of [fuchsia.diagnostics/FormattedContent] structs
    /// with a format dictated by the format_settings argument provided to the Reader protocol
    /// which spawned this BatchIterator.
    ///
    /// An empty vector implies that the data hierarchy has been fully iterated, and subsequent
    /// GetNext calls will always return the empty vector.
    ///
    /// When the BatchIterator is serving results via subscription model, calls to GetNext will
    /// hang until there is new data available, it will not return an empty vector.
    ///
    /// - returns a vector of FormattedContent structs. Clients connected to a
    ///   Batch are expected to call GetNext() until an empty vector
    ///   is returned, denoting that the entire data hierarchy has been read.
    ///
    /// * error a [fuchsia.diagnostics/ReaderError]
    ///   value indicating that there was an issue reading the underlying data hierarchies
    ///   or formatting those hierarchies to populate the `batch`. Note, these
    ///   issues do not include a single component's data hierarchy failing to be read.
    ///   The iterator is tolerant of individual component data sources failing to be read,
    ///   whether that failure is a timeout or a malformed binary file.
    ///   In the event that a GetNext call fails, that subset of the data hierarchy results is
    ///   dropped, but future calls to GetNext will provide new subsets of
    ///   FormattedDataHierarchies.
    GetNext { responder: BatchIteratorGetNextResponder },
    /// Indiciates that the BatchIterator has been connected. If the
    /// BatchIterator hasn't been connected, this method will hang until it is.
    WaitForReady { responder: BatchIteratorWaitForReadyResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: BatchIteratorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl BatchIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(BatchIteratorGetNextResponder)> {
        if let BatchIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_ready(self) -> Option<(BatchIteratorWaitForReadyResponder)> {
        if let BatchIteratorRequest::WaitForReady { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BatchIteratorRequest::GetNext { .. } => "get_next",
            BatchIteratorRequest::WaitForReady { .. } => "wait_for_ready",
            BatchIteratorRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            BatchIteratorRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for BatchIteratorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl BatchIteratorControlHandle {}

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

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

impl fidl::endpoints::Responder for BatchIteratorGetNextResponder {
    type ControlHandle = BatchIteratorControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<Vec<FormattedContent>, ReaderError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            BatchIteratorGetNextResponse,
            ReaderError,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.as_mut().map_err(|e| *e).map(|batch| (batch.as_mut_slice(),)),
            ),
            self.tx_id,
            0x781986486c6254a5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

impl fidl::endpoints::Responder for BatchIteratorWaitForReadyResponder {
    type ControlHandle = BatchIteratorControlHandle;

    fn control_handle(&self) -> &BatchIteratorControlHandle {
        &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 BatchIteratorWaitForReadyResponder {
    /// 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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x70598ee271597603,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for LogSettingsMarker {
    type Proxy = LogSettingsProxy;
    type RequestStream = LogSettingsRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LogSettingsSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.LogSettings";
}
impl fidl::endpoints::DiscoverableProtocolMarker for LogSettingsMarker {}

pub trait LogSettingsProxyInterface: Send + Sync {
    fn r#register_interest(&self, selectors: &[LogInterestSelector]) -> Result<(), fidl::Error>;
    type SetInterestResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#set_interest(&self, selectors: &[LogInterestSelector]) -> Self::SetInterestResponseFut;
    type SetComponentInterestResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#set_component_interest(
        &self,
        payload: &LogSettingsSetComponentInterestRequest,
    ) -> Self::SetComponentInterestResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LogSettingsSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LogSettingsSynchronousProxy {
    type Proxy = LogSettingsProxy;
    type Protocol = LogSettingsMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl LogSettingsSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <LogSettingsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    pub fn r#register_interest(
        &self,
        mut selectors: &[LogInterestSelector],
    ) -> Result<(), fidl::Error> {
        self.client.send::<LogSettingsRegisterInterestRequest>(
            (selectors,),
            0x49d7c14eec975fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone. Each matched component minimum interest is updated with the
    /// new minimum interest in the set.
    pub fn r#set_interest(
        &self,
        mut selectors: &[LogInterestSelector],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<LogSettingsSetInterestRequest, fidl::encoding::EmptyPayload>(
                (selectors,),
                0x71beced9d2411f90,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetComponentInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetComponentInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetComponentInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone, unless persist is set to true. Each matched component minimum
    /// interest is updated with the new minimum interest in the set.
    pub fn r#set_component_interest(
        &self,
        mut payload: &LogSettingsSetComponentInterestRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<LogSettingsSetComponentInterestRequest, fidl::encoding::EmptyPayload>(
                payload,
                0x35f7004d2367f6c1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LogSettingsProxy {
    type Protocol = LogSettingsMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl LogSettingsProxy {
    /// Create a new Proxy for fuchsia.diagnostics/LogSettings.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LogSettingsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> LogSettingsEventStream {
        LogSettingsEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#register_interest(
        &self,
        mut selectors: &[LogInterestSelector],
    ) -> Result<(), fidl::Error> {
        LogSettingsProxyInterface::r#register_interest(self, selectors)
    }

    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone. Each matched component minimum interest is updated with the
    /// new minimum interest in the set.
    pub fn r#set_interest(
        &self,
        mut selectors: &[LogInterestSelector],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        LogSettingsProxyInterface::r#set_interest(self, selectors)
    }

    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetComponentInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetComponentInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetComponentInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone, unless persist is set to true. Each matched component minimum
    /// interest is updated with the new minimum interest in the set.
    pub fn r#set_component_interest(
        &self,
        mut payload: &LogSettingsSetComponentInterestRequest,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        LogSettingsProxyInterface::r#set_component_interest(self, payload)
    }
}

impl LogSettingsProxyInterface for LogSettingsProxy {
    fn r#register_interest(
        &self,
        mut selectors: &[LogInterestSelector],
    ) -> Result<(), fidl::Error> {
        self.client.send::<LogSettingsRegisterInterestRequest>(
            (selectors,),
            0x49d7c14eec975fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SetInterestResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_interest(
        &self,
        mut selectors: &[LogInterestSelector],
    ) -> Self::SetInterestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x71beced9d2411f90,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<LogSettingsSetInterestRequest, ()>(
            (selectors,),
            0x71beced9d2411f90,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetComponentInterestResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_component_interest(
        &self,
        mut payload: &LogSettingsSetComponentInterestRequest,
    ) -> Self::SetComponentInterestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35f7004d2367f6c1,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<LogSettingsSetComponentInterestRequest, ()>(
            payload,
            0x35f7004d2367f6c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for LogSettingsRequestStream {
    type Protocol = LogSettingsMarker;
    type ControlHandle = LogSettingsControlHandle;

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

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

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

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

impl futures::Stream for LogSettingsRequestStream {
    type Item = Result<LogSettingsRequest, 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 LogSettingsRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x49d7c14eec975fb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LogSettingsRegisterInterestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LogSettingsRegisterInterestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LogSettingsControlHandle { inner: this.inner.clone() };
                        Ok(LogSettingsRequest::RegisterInterest {
                            selectors: req.selectors,

                            control_handle,
                        })
                    }
                    0x71beced9d2411f90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LogSettingsSetInterestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LogSettingsSetInterestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LogSettingsControlHandle { inner: this.inner.clone() };
                        Ok(LogSettingsRequest::SetInterest {
                            selectors: req.selectors,

                            responder: LogSettingsSetInterestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35f7004d2367f6c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LogSettingsSetComponentInterestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LogSettingsSetComponentInterestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LogSettingsControlHandle { inner: this.inner.clone() };
                        Ok(LogSettingsRequest::SetComponentInterest {
                            payload: req,
                            responder: LogSettingsSetComponentInterestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <LogSettingsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol allows clients to modify the logging behavior of components
/// in the system.
#[derive(Debug)]
pub enum LogSettingsRequest {
    RegisterInterest {
        selectors: Vec<LogInterestSelector>,
        control_handle: LogSettingsControlHandle,
    },
    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone. Each matched component minimum interest is updated with the
    /// new minimum interest in the set.
    SetInterest { selectors: Vec<LogInterestSelector>, responder: LogSettingsSetInterestResponder },
    /// Requests a change in interest for the matched components.
    ///
    /// Each component holds a set of requested interests.
    ///
    /// When a new request on LogSettings#SetComponentInterest is received,
    /// the sets for matched components receive the new minimum interest.
    /// If the interest is less than the previous minimum interest, then a
    /// `SetComponentInterest` request is sent with the new minimum interest.
    ///
    /// If a connection to `LogSettings` sends another `SetComponentInterest`
    /// request, its previous interest request will be undone.
    ///
    /// When the connection to `LogSettings` is finished, the interests are
    /// undone, unless persist is set to true. Each matched component minimum
    /// interest is updated with the new minimum interest in the set.
    SetComponentInterest {
        payload: LogSettingsSetComponentInterestRequest,
        responder: LogSettingsSetComponentInterestResponder,
    },
}

impl LogSettingsRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_interest(
        self,
    ) -> Option<(Vec<LogInterestSelector>, LogSettingsControlHandle)> {
        if let LogSettingsRequest::RegisterInterest { selectors, control_handle } = self {
            Some((selectors, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_interest(
        self,
    ) -> Option<(Vec<LogInterestSelector>, LogSettingsSetInterestResponder)> {
        if let LogSettingsRequest::SetInterest { selectors, responder } = self {
            Some((selectors, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_component_interest(
        self,
    ) -> Option<(LogSettingsSetComponentInterestRequest, LogSettingsSetComponentInterestResponder)>
    {
        if let LogSettingsRequest::SetComponentInterest { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LogSettingsRequest::RegisterInterest { .. } => "register_interest",
            LogSettingsRequest::SetInterest { .. } => "set_interest",
            LogSettingsRequest::SetComponentInterest { .. } => "set_component_interest",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for LogSettingsControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl LogSettingsControlHandle {}

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

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

impl fidl::endpoints::Responder for LogSettingsSetInterestResponder {
    type ControlHandle = LogSettingsControlHandle;

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

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

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

impl fidl::endpoints::Responder for LogSettingsSetComponentInterestResponder {
    type ControlHandle = LogSettingsControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for LogStreamMarker {
    type Proxy = LogStreamProxy;
    type RequestStream = LogStreamRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LogStreamSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.LogStream";
}
impl fidl::endpoints::DiscoverableProtocolMarker for LogStreamMarker {}

pub trait LogStreamProxyInterface: Send + Sync {
    fn r#connect(&self, socket: fidl::Socket, opts: &LogStreamOptions) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LogStreamSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LogStreamSynchronousProxy {
    type Proxy = LogStreamProxy;
    type Protocol = LogStreamMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl LogStreamSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <LogStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Enables clients to stream all logs stored in the Archivist.
    /// Expects a Datagram socket handle that can be written to.
    ///
    /// Logs will be written in the original FXT format with two additional
    /// arguments appended at the end of the record depending on the options
    /// passed:
    ///
    ///     - `$__moniker`: the moniker of the component that emitted the log.
    ///     - `$__url`: the URL of the component that emitted the log.
    ///     - `$__rolled_out`: the number of logs that were rolled out from the
    ///       buffer before this one.
    pub fn r#connect(
        &self,
        mut socket: fidl::Socket,
        mut opts: &LogStreamOptions,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LogStreamConnectRequest>(
            (socket, opts),
            0x745eb34f10d51a88,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LogStreamProxy {
    type Protocol = LogStreamMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl LogStreamProxy {
    /// Create a new Proxy for fuchsia.diagnostics/LogStream.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LogStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> LogStreamEventStream {
        LogStreamEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Enables clients to stream all logs stored in the Archivist.
    /// Expects a Datagram socket handle that can be written to.
    ///
    /// Logs will be written in the original FXT format with two additional
    /// arguments appended at the end of the record depending on the options
    /// passed:
    ///
    ///     - `$__moniker`: the moniker of the component that emitted the log.
    ///     - `$__url`: the URL of the component that emitted the log.
    ///     - `$__rolled_out`: the number of logs that were rolled out from the
    ///       buffer before this one.
    pub fn r#connect(
        &self,
        mut socket: fidl::Socket,
        mut opts: &LogStreamOptions,
    ) -> Result<(), fidl::Error> {
        LogStreamProxyInterface::r#connect(self, socket, opts)
    }
}

impl LogStreamProxyInterface for LogStreamProxy {
    fn r#connect(
        &self,
        mut socket: fidl::Socket,
        mut opts: &LogStreamOptions,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LogStreamConnectRequest>(
            (socket, opts),
            0x745eb34f10d51a88,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl LogStreamEvent {
    /// Decodes a message buffer as a [`LogStreamEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<LogStreamEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(LogStreamEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <LogStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for LogStreamRequestStream {
    type Protocol = LogStreamMarker;
    type ControlHandle = LogStreamControlHandle;

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

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

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

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

impl futures::Stream for LogStreamRequestStream {
    type Item = Result<LogStreamRequest, 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 LogStreamRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x745eb34f10d51a88 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LogStreamConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LogStreamConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LogStreamControlHandle { inner: this.inner.clone() };
                        Ok(LogStreamRequest::Connect {
                            socket: req.socket,
                            opts: req.opts,

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

#[derive(Debug)]
pub enum LogStreamRequest {
    /// Enables clients to stream all logs stored in the Archivist.
    /// Expects a Datagram socket handle that can be written to.
    ///
    /// Logs will be written in the original FXT format with two additional
    /// arguments appended at the end of the record depending on the options
    /// passed:
    ///
    ///     - `$__moniker`: the moniker of the component that emitted the log.
    ///     - `$__url`: the URL of the component that emitted the log.
    ///     - `$__rolled_out`: the number of logs that were rolled out from the
    ///       buffer before this one.
    Connect { socket: fidl::Socket, opts: LogStreamOptions, control_handle: LogStreamControlHandle },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: LogStreamControlHandle,
        method_type: fidl::MethodType,
    },
}

impl LogStreamRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(self) -> Option<(fidl::Socket, LogStreamOptions, LogStreamControlHandle)> {
        if let LogStreamRequest::Connect { socket, opts, control_handle } = self {
            Some((socket, opts, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LogStreamRequest::Connect { .. } => "connect",
            LogStreamRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            LogStreamRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for LogStreamControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl LogStreamControlHandle {}

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ArchiveAccessorStreamDiagnosticsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArchiveAccessorStreamDiagnosticsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArchiveAccessorStreamDiagnosticsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArchiveAccessorStreamDiagnosticsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <StreamParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_parameters),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BatchIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.result_stream),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<StreamParameters, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BatchIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ArchiveAccessorStreamDiagnosticsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArchiveAccessorStreamDiagnosticsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArchiveAccessorStreamDiagnosticsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                stream_parameters: fidl::new_empty!(
                    StreamParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                result_stream: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BatchIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BatchIteratorGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                batch: fidl::new_empty!(fidl::encoding::Vector<FormattedContent, 64>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            LogStreamConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut LogStreamConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogStreamConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LogStreamConnectRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        16392,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.socket
                    ),
                    <LogStreamOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.opts),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    16392,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<LogStreamOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            LogStreamConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogStreamConnectRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for LogStreamConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect),
                opts: fidl::new_empty!(
                    LogStreamOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            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 + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            fidl::decode!(
                LogStreamOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.opts,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FormattedContent {
        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 FormattedContent {
        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<FormattedContent, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FormattedContent
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FormattedContent>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            FormattedContent::Json(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_mem::Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            FormattedContent::Text(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_mem::Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            FormattedContent::Cbor(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            FormattedContent::Fxt(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            FormattedContent::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <fidl_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                3 => <fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Json(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = FormattedContent::Json(fidl::new_empty!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Json(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Text(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = FormattedContent::Text(fidl::new_empty!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Text(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Cbor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = FormattedContent::Cbor(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Cbor(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Fxt(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = FormattedContent::Fxt(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Fxt(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = FormattedContent::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}