fdomain_fuchsia_diagnostics/

fdomain_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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
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: fdomain_client::fidl::ServerEnd<BatchIteratorMarker>,
}

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SampleCommitRequest {
    /// Where results are sent.
    pub sink: fdomain_client::fidl::ClientEnd<SampleSinkMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct SampleSetRequest {
    /// The data configuration for this sample server.
    pub sample_parameters: SampleParameters,
}

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

#[derive(Debug, PartialEq)]
pub struct SampleSinkOnSampleReadiedRequest {
    pub event: SampleSinkResult,
}

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

/// `SampleReady` carries the data for a ready-to-consume sample.
#[derive(Debug, Default, PartialEq)]
pub struct SampleReady {
    /// `batch_iter` is the `BatchIterator` over the set of data.
    pub batch_iter: Option<fdomain_client::fidl::ClientEnd<BatchIteratorMarker>>,
    /// `seconds_since_start` is `ticks * interval_secs` for the current
    /// polling period.
    ///
    /// This can be used to check whether a value in the batch corresponds
    /// to a `SampleDatum`, assuming you have not registered the same selector
    /// with different `SampleStrategy` types. The procedure is:
    ///
    /// 1) Resolve `batch_iter` into a set of Inspect hierarchies.
    /// 2) Filter the set of `SampleDatum`s committed to this server with
    ///    the predicate `seconds_since_start % datum.interval_secs == 0`.
    /// 3) Any selector from the filtered `SampleDatum`s that matches data
    ///    in the resolved Inspect hierarchies is valid.
    ///
    /// If you DO have one selector registered twice with different strategies,
    /// you must maintain a local cache and check the value yourself.
    pub seconds_since_start: Option<i64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// 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(fdomain_fuchsia_mem::Buffer),
    /// A diagnostics schema encoded as text.
    /// The VMO will contain up to 1mb of diagnostics data.
    Text(fdomain_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(fdomain_client::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(fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect> for FormattedContent {}

#[derive(Debug)]
pub enum SampleSinkResult {
    /// `SampleReady` provides a `BatchIterator` for the client containing all
    /// ready samples.
    ///
    /// This will include all `SampleStrategy::ALWAYS` samples and all
    /// `SampleStrategy::ON_DIFF` for which there was a changed value.
    Ready(SampleReady),
    /// `error` provides an interface for receiving runtime errors from the
    /// sample server.
    Error(RuntimeError),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for ArchiveAccessorMarker {
    type Proxy = ArchiveAccessorProxy;
    type RequestStream = ArchiveAccessorRequestStream;

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

pub trait ArchiveAccessorProxyInterface: Send + Sync {
    fn r#stream_diagnostics(
        &self,
        stream_parameters: &StreamParameters,
        result_stream: fdomain_client::fidl::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, Clone)]
pub struct ArchiveAccessorProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::fidl::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<(), fdomain_client::fidl::FDomainResourceDialect> {
        ArchiveAccessorProxyInterface::r#wait_for_ready(self)
    }
}

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

    type WaitForReadyResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x122963198011bd24,
            >(_buf?)?
            .into_result_fdomain::<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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x20c73e2ecd653c3e => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(ArchiveAccessorStreamDiagnosticsRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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 fdomain_client::fidl::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: fdomain_client::fidl::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,
        fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for BatchIteratorMarker {
    type Proxy = BatchIteratorProxy;
    type RequestStream = BatchIteratorRequestStream;

    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, Clone)]
pub struct BatchIteratorProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BatchIteratorProxyInterface::r#get_next(self)
    }

    /// Indicates 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<(), fdomain_client::fidl::FDomainResourceDialect> {
        BatchIteratorProxyInterface::r#wait_for_ready(self)
    }
}

impl BatchIteratorProxyInterface for BatchIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        BatchIteratorGetNextResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BatchIteratorGetNextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<BatchIteratorGetNextResponse, ReaderError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x781986486c6254a5,
            >(_buf?)?
            .into_result_fdomain::<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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x70598ee271597603,
            >(_buf?)?
            .into_result_fdomain::<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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x781986486c6254a5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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 fdomain_client::fidl::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 },
    /// Indicates 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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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 fdomain_client::fidl::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 fdomain_client::fidl::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 LogFlusherMarker;

impl fdomain_client::fidl::ProtocolMarker for LogFlusherMarker {
    type Proxy = LogFlusherProxy;
    type RequestStream = LogFlusherRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.LogFlusher";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for LogFlusherMarker {}

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

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

impl fdomain_client::fidl::Proxy for LogFlusherProxy {
    type Protocol = LogFlusherMarker;

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

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

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

impl LogFlusherProxy {
    /// Create a new Proxy for fuchsia.diagnostics/LogFlusher.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <LogFlusherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Flushes all pending logs through the logging pipeline
    /// to the serial port. Logs written to sockets prior to
    /// the call to Flush are guaranteed to be fully written
    /// to serial when this returns. Logs written to sockets
    /// after this call has been received by Archivist are
    /// not guaranteed to be flushed.
    /// Additionally, sockets must actually be connected to the Archivist
    /// before this call is made. If a socket hasn't been
    /// received by Archivist yet, those logs may be dropped.
    /// To ensure that logs are properly flushed, make sure
    /// to wait for the initial interest when logging.
    /// Important note: This may be called from the host,
    /// but host sockets will NOT be flushed by this method.
    /// If you write data from the host (not on the device,
    /// there is no guarantee that such logs will ever be printed).
    pub fn r#wait_until_flushed(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        LogFlusherProxyInterface::r#wait_until_flushed(self)
    }
}

impl LogFlusherProxyInterface for LogFlusherProxy {
    type WaitUntilFlushedResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#wait_until_flushed(&self) -> Self::WaitUntilFlushedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7dc4892e46748b5b,
            >(_buf?)?
            .into_result_fdomain::<LogFlusherMarker>("wait_until_flushed")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x7dc4892e46748b5b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl LogFlusherEvent {
    /// Decodes a message buffer as a [`LogFlusherEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<LogFlusherEvent, 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(LogFlusherEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <LogFlusherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.diagnostics/LogFlusher.
pub struct LogFlusherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for LogFlusherRequestStream {
    type Protocol = LogFlusherMarker;
    type ControlHandle = LogFlusherControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7dc4892e46748b5b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LogFlusherControlHandle { inner: this.inner.clone() };
                        Ok(LogFlusherRequest::WaitUntilFlushed {
                            responder: LogFlusherWaitUntilFlushedResponder {
                                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(LogFlusherRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: LogFlusherControlHandle { 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(LogFlusherRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: LogFlusherControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <LogFlusherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum LogFlusherRequest {
    /// Flushes all pending logs through the logging pipeline
    /// to the serial port. Logs written to sockets prior to
    /// the call to Flush are guaranteed to be fully written
    /// to serial when this returns. Logs written to sockets
    /// after this call has been received by Archivist are
    /// not guaranteed to be flushed.
    /// Additionally, sockets must actually be connected to the Archivist
    /// before this call is made. If a socket hasn't been
    /// received by Archivist yet, those logs may be dropped.
    /// To ensure that logs are properly flushed, make sure
    /// to wait for the initial interest when logging.
    /// Important note: This may be called from the host,
    /// but host sockets will NOT be flushed by this method.
    /// If you write data from the host (not on the device,
    /// there is no guarantee that such logs will ever be printed).
    WaitUntilFlushed { responder: LogFlusherWaitUntilFlushedResponder },
    /// 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: LogFlusherControlHandle,
        method_type: fidl::MethodType,
    },
}

impl LogFlusherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_until_flushed(self) -> Option<(LogFlusherWaitUntilFlushedResponder)> {
        if let LogFlusherRequest::WaitUntilFlushed { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

impl LogFlusherControlHandle {}

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

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

impl fdomain_client::fidl::Responder for LogFlusherWaitUntilFlushedResponder {
    type ControlHandle = LogFlusherControlHandle;

    fn control_handle(&self) -> &LogFlusherControlHandle {
        &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 LogFlusherWaitUntilFlushedResponder {
    /// 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,
            0x7dc4892e46748b5b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for LogSettingsMarker {
    type Proxy = LogSettingsProxy;
    type RequestStream = LogSettingsRequestStream;

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

pub trait LogSettingsProxyInterface: Send + Sync {
    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, Clone)]
pub struct LogSettingsProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

    /// 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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect> {
        LogSettingsProxyInterface::r#set_component_interest(self, payload)
    }
}

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

    type SetComponentInterestResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#set_component_interest(
        &self,
        mut payload: &LogSettingsSetComponentInterestRequest,
    ) -> Self::SetComponentInterestResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x71beced9d2411f90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LogSettingsSetInterestRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol allows clients to modify the logging behavior of components
/// in the system.
#[derive(Debug)]
pub enum LogSettingsRequest {
    /// 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_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::SetInterest { .. } => "set_interest",
            LogSettingsRequest::SetComponentInterest { .. } => "set_component_interest",
        }
    }
}

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

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

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

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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for LogStreamMarker {
    type Proxy = LogStreamProxy;
    type RequestStream = LogStreamRequestStream;

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

pub trait LogStreamProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        socket: fdomain_client::Socket,
        opts: &LogStreamOptions,
    ) -> Result<(), fidl::Error>;
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::Socket,
        mut opts: &LogStreamOptions,
    ) -> Result<(), fidl::Error> {
        LogStreamProxyInterface::r#connect(self, socket, opts)
    }
}

impl LogStreamProxyInterface for LogStreamProxy {
    fn r#connect(
        &self,
        mut socket: fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x745eb34f10d51a88 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LogStreamConnectRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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: fdomain_client::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<(fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

impl LogStreamControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for SampleMarker {
    type Proxy = SampleProxy;
    type RequestStream = SampleRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.Sample";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for SampleMarker {}
pub type SampleCommitResult = Result<(), ConfigurationError>;

pub trait SampleProxyInterface: Send + Sync {
    fn r#set(&self, sample_parameters: &SampleParameters) -> Result<(), fidl::Error>;
    type CommitResponseFut: std::future::Future<Output = Result<SampleCommitResult, fidl::Error>>
        + Send;
    fn r#commit(
        &self,
        sink: fdomain_client::fidl::ClientEnd<SampleSinkMarker>,
    ) -> Self::CommitResponseFut;
}

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

impl fdomain_client::fidl::Proxy for SampleProxy {
    type Protocol = SampleMarker;

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

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

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

impl SampleProxy {
    /// Create a new Proxy for fuchsia.diagnostics/Sample.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SampleMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Add sample parameters.
    ///
    /// Since this is limited by channel size, this API paginates at 300
    /// items. That should fit in a channel unless a selector is particularly
    /// gigantic.
    ///
    /// Use `Commit` to indicate that all samples are sent over.
    pub fn r#set(&self, mut sample_parameters: &SampleParameters) -> Result<(), fidl::Error> {
        SampleProxyInterface::r#set(self, sample_parameters)
    }

    /// `Commit` returns errors quickly, as all configuration is validated
    /// before the first sample is taken.
    pub fn r#commit(
        &self,
        mut sink: fdomain_client::fidl::ClientEnd<SampleSinkMarker>,
    ) -> fidl::client::QueryResponseFut<
        SampleCommitResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SampleProxyInterface::r#commit(self, sink)
    }
}

impl SampleProxyInterface for SampleProxy {
    fn r#set(&self, mut sample_parameters: &SampleParameters) -> Result<(), fidl::Error> {
        self.client.send::<SampleSetRequest>(
            (sample_parameters,),
            0x421a79bdbf45418e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type CommitResponseFut = fidl::client::QueryResponseFut<
        SampleCommitResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#commit(
        &self,
        mut sink: fdomain_client::fidl::ClientEnd<SampleSinkMarker>,
    ) -> Self::CommitResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SampleCommitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, ConfigurationError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x25a3bc5f26787e9b,
            >(_buf?)?
            .into_result_fdomain::<SampleMarker>("commit")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SampleCommitRequest, SampleCommitResult>(
            (sink,),
            0x25a3bc5f26787e9b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl SampleEvent {
    /// Decodes a message buffer as a [`SampleEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SampleEvent, 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(SampleEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <SampleMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.diagnostics/Sample.
pub struct SampleRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for SampleRequestStream {
    type Protocol = SampleMarker;
    type ControlHandle = SampleControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x421a79bdbf45418e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SampleSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SampleSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SampleControlHandle { inner: this.inner.clone() };
                        Ok(SampleRequest::Set {
                            sample_parameters: req.sample_parameters,

                            control_handle,
                        })
                    }
                    0x25a3bc5f26787e9b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SampleCommitRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SampleCommitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SampleControlHandle { inner: this.inner.clone() };
                        Ok(SampleRequest::Commit {
                            sink: req.sink,

                            responder: SampleCommitResponder {
                                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(SampleRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SampleControlHandle { 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(SampleRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SampleControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SampleMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Configure Archivist to alert you periodically about the state of data
/// provided via `SampleParameters`.
///
/// If the given configuration results in a hit, a `BatchIterator` is sent
/// over the `sink` provided. That iterator may be drained, and then the
/// `sink` will go quiet until the next hit.
///
/// Archivist does not inform the client which data result in a success,
/// because it has not inherent advantaged ability to do so. Clients who
/// need to know which data was queried should cache their selectors and
/// use `selectors::select_from_hierarchy` (or similar in C++).
#[derive(Debug)]
pub enum SampleRequest {
    /// Add sample parameters.
    ///
    /// Since this is limited by channel size, this API paginates at 300
    /// items. That should fit in a channel unless a selector is particularly
    /// gigantic.
    ///
    /// Use `Commit` to indicate that all samples are sent over.
    Set { sample_parameters: SampleParameters, control_handle: SampleControlHandle },
    /// `Commit` returns errors quickly, as all configuration is validated
    /// before the first sample is taken.
    Commit {
        sink: fdomain_client::fidl::ClientEnd<SampleSinkMarker>,
        responder: SampleCommitResponder,
    },
    /// 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: SampleControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SampleRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set(self) -> Option<(SampleParameters, SampleControlHandle)> {
        if let SampleRequest::Set { sample_parameters, control_handle } = self {
            Some((sample_parameters, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_commit(
        self,
    ) -> Option<(fdomain_client::fidl::ClientEnd<SampleSinkMarker>, SampleCommitResponder)> {
        if let SampleRequest::Commit { sink, responder } = self {
            Some((sink, responder))
        } else {
            None
        }
    }

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

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

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

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

impl SampleControlHandle {}

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

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

impl fdomain_client::fidl::Responder for SampleCommitResponder {
    type ControlHandle = SampleControlHandle;

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

    fn send_raw(&self, mut result: Result<(), ConfigurationError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            ConfigurationError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x25a3bc5f26787e9b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for SampleSinkMarker {
    type Proxy = SampleSinkProxy;
    type RequestStream = SampleSinkRequestStream;

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

pub trait SampleSinkProxyInterface: Send + Sync {
    fn r#on_sample_readied(&self, event: SampleSinkResult) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for SampleSinkProxy {
    type Protocol = SampleSinkMarker;

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

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

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

impl SampleSinkProxy {
    /// Create a new Proxy for fuchsia.diagnostics/SampleSink.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SampleSinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#on_sample_readied(&self, mut event: SampleSinkResult) -> Result<(), fidl::Error> {
        SampleSinkProxyInterface::r#on_sample_readied(self, event)
    }
}

impl SampleSinkProxyInterface for SampleSinkProxy {
    fn r#on_sample_readied(&self, mut event: SampleSinkResult) -> Result<(), fidl::Error> {
        self.client.send::<SampleSinkOnSampleReadiedRequest>(
            (&mut event,),
            0x39096d97ed03335f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

    /// Decodes a message buffer as a [`SampleSinkEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SampleSinkEvent, 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 {
            0x3dc94ca1e1290894 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SampleSinkEvent::OnNowOrNever {}))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SampleSinkEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <SampleSinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.diagnostics/SampleSink.
pub struct SampleSinkRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for SampleSinkRequestStream {
    type Protocol = SampleSinkMarker;
    type ControlHandle = SampleSinkControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x39096d97ed03335f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SampleSinkOnSampleReadiedRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SampleSinkOnSampleReadiedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SampleSinkControlHandle { inner: this.inner.clone() };
                        Ok(SampleSinkRequest::OnSampleReadied { event: req.event, control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(SampleSinkRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SampleSinkControlHandle { 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(SampleSinkRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SampleSinkControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SampleSinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `SampleSink` is served by the client, in order to be notified when samples
/// are ready.
#[derive(Debug)]
pub enum SampleSinkRequest {
    OnSampleReadied {
        event: SampleSinkResult,
        control_handle: SampleSinkControlHandle,
    },
    /// 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: SampleSinkControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SampleSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_sample_readied(self) -> Option<(SampleSinkResult, SampleSinkControlHandle)> {
        if let SampleSinkRequest::OnSampleReadied { event, control_handle } = self {
            Some((event, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl SampleSinkControlHandle {
    pub fn send_on_now_or_never(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x3dc94ca1e1290894,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.stream_parameters,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<BatchIteratorMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BatchIteratorGetNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BatchIteratorGetNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BatchIteratorGetNextResponse, fdomain_client::fidl::FDomainResourceDialect>::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>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BatchIteratorGetNextResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for BatchIteratorGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                batch: fidl::new_empty!(fidl::encoding::Vector<FormattedContent, 64>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<FormattedContent, 64>, fdomain_client::fidl::FDomainResourceDialect, &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LogStreamConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LogStreamConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LogStreamConnectRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::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<
                    fdomain_client::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    16392,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<LogStreamOptions, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            LogStreamConnectRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for LogStreamConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                socket: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 16392>, fdomain_client::fidl::FDomainResourceDialect),
                opts: fidl::new_empty!(
                    LogStreamOptions,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for SampleCommitRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sink: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<SampleSinkMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

    impl SampleReady {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.seconds_since_start {
                return 2;
            }
            if let Some(_) = self.batch_iter {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<BatchIteratorMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.batch_iter.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<BatchIteratorMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<BatchIteratorMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.seconds_since_start.get_or_insert_with(|| {
                    fidl::new_empty!(i64, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    i64,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for 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, fdomain_client::fidl::FDomainResourceDialect>
        for &mut FormattedContent
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FormattedContent>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            FormattedContent::Json(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fdomain_fuchsia_mem::Buffer, fdomain_client::fidl::FDomainResourceDialect>(
                    <fdomain_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::<fdomain_fuchsia_mem::Buffer, fdomain_client::fidl::FDomainResourceDialect>(
                    <fdomain_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<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect>(
                    <fidl::encoding::HandleType<fdomain_client::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<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect>(
                    <fidl::encoding::HandleType<fdomain_client::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, fdomain_client::fidl::FDomainResourceDialect>
        for FormattedContent
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

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

            let member_inline_size = match ordinal {
                1 => <fdomain_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <fdomain_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                3 => <fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <fidl::encoding::HandleType<
                    fdomain_client::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!(
                            fdomain_fuchsia_mem::Buffer,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Json(ref mut val) = self {
                        fidl::decode!(
                            fdomain_fuchsia_mem::Buffer,
                            fdomain_client::fidl::FDomainResourceDialect,
                            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!(
                            fdomain_fuchsia_mem::Buffer,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Text(ref mut val) = self {
                        fidl::decode!(
                            fdomain_fuchsia_mem::Buffer,
                            fdomain_client::fidl::FDomainResourceDialect,
                            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<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Cbor(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, 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<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let FormattedContent::Fxt(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, 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(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SampleSinkResult {
        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 SampleSinkResult {
        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<SampleSinkResult, fdomain_client::fidl::FDomainResourceDialect>
        for &mut SampleSinkResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SampleSinkResult>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                SampleSinkResult::Ready(ref mut val) => fidl::encoding::encode_in_envelope::<
                    SampleReady,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <SampleReady as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleSinkResult::Error(ref val) => fidl::encoding::encode_in_envelope::<
                    RuntimeError,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <RuntimeError as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleSinkResult::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

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

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

            let member_inline_size = match ordinal {
                1 => <SampleReady as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <RuntimeError 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 SampleSinkResult::Ready(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleSinkResult::Ready(fidl::new_empty!(
                            SampleReady,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleSinkResult::Ready(ref mut val) = self {
                        fidl::decode!(
                            SampleReady,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleSinkResult::Error(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleSinkResult::Error(fidl::new_empty!(
                            RuntimeError,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleSinkResult::Error(ref mut val) = self {
                        fidl::decode!(
                            RuntimeError,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = SampleSinkResult::__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(())
        }
    }
}