fdomain_fuchsia_hardware_audio/

fdomain_fuchsia_hardware_audio.rs

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

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

use bitflags::bitflags;
use fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_hardware_audio_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub type VmoInfos = Vec<VmoInfo>;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CodecConnectorConnectRequest {
    pub codec_protocol: fdomain_client::fidl::ServerEnd<CodecMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CompositeConnectorConnectRequest {
    pub composite_protocol: fdomain_client::fidl::ServerEnd<CompositeMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct CompositeCreatePacketStreamRequest {
    pub processing_element_id: u64,
    pub format: Format2,
    pub packet_stream_control: fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct CompositeCreateRingBufferRequest {
    pub processing_element_id: u64,
    pub format: Format2,
    pub ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DaiConnectorConnectRequest {
    pub dai_protocol: fdomain_client::fidl::ServerEnd<DaiMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct DaiCreateRingBufferRequest {
    pub dai_format: DaiFormat,
    pub ring_buffer_format: Format,
    pub ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PacketStreamControlAllocateVmosResponse {
    pub vmos: Vec<VmoInfo>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RingBufferGetVmoResponse {
    pub num_frames: u32,
    pub ring_buffer: fdomain_client::Vmo,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StreamConfigConnectorConnectRequest {
    pub protocol: fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct StreamConfigCreateRingBufferRequest {
    pub format: Format,
    pub ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PacketStreamControlSetPacketStreamSinkRequest {
    pub stream: Option<fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PacketStreamControlGetPacketStreamSinkResponse {
    pub stream: Option<fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PacketStreamSinkPutPacketRequest {
    /// Location of the payload for this packet.
    ///
    /// Required.
    pub payload: Option<DataTransfer>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct RegisterVmosConfig {
    /// The list of VMOs to register with the driver.
    ///
    /// Required.
    pub vmo_infos: Option<Vec<VmoInfo>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// VMO information for registering VMOs. Used in `RegisterVmos` and `AllocateVmos` to pair
/// a VMO handle with a unique ID.
#[derive(Debug, Default, PartialEq)]
pub struct VmoInfo {
    /// ID corresponding to the VMO.
    ///
    /// Required.
    pub id: Option<u64>,
    /// Handle to the VMO.
    ///
    /// Required.
    pub vmo: Option<fdomain_client::Vmo>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// This describes a VMO section containing audio data.
#[derive(Debug, Default, PartialEq)]
pub struct VmoTransfer {
    /// ID of a VMO that was previously registered or allocated.
    ///
    /// Required.
    pub vmo_id: Option<u64>,
    /// Offset into the VMO to start reading or writing.
    /// This is relative to the start of that VMO.
    ///
    /// Required.
    pub vmo_offset: Option<u64>,
    /// Number of bytes to read/write from/to this VMO region.
    ///
    /// Required.
    pub payload_size: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Data to be transferred. There are two supported ways data may be conveyed, corresponding to the
/// two members of the DataTransfer union:
///
/// 1) vmo_transfer: A region within a VMO previously known to the driver. This VMO must have been
///    established via `PacketStreamControl.RegisterVmos` (if client-allocated) or
///    `PacketStreamControl.AllocateVmos` (if driver-allocated). Future requests refer to this
///    buffer by the unique `vmo_id`. Because VMOs are reused across requests, the one-time
///    cost of pinning/mapping is amortized.
///
/// 2) data: The payload is provided directly within the message. This mode is intended for
///    small transfers or control information, not high-throughput streaming.
#[derive(Debug)]
pub enum DataTransfer {
    /// Data is stored in a region of a registered VMO.
    /// Requires `PacketStreamProperties.supported_buffer_types` to include `CLIENT_OWNED`
    /// or `DRIVER_OWNED`.
    VmoTransfer(VmoTransfer),
    /// Embedded data buffer.
    /// Requires `PacketStreamProperties.supported_buffer_types` to include `INLINE`.
    InlineData(Vec<u8>),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

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

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

impl DataTransfer {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::VmoTransfer(_) => 1,
            Self::InlineData(_) => 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 DataTransfer {}

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

impl fdomain_client::fidl::ProtocolMarker for CodecMarker {
    type Proxy = CodecProxy;
    type RequestStream = CodecRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Codec";
}
pub type CodecGetDaiFormatsResult = Result<Vec<DaiSupportedFormats>, i32>;
pub type CodecSetDaiFormatResult = Result<CodecFormatInfo, i32>;

pub trait CodecProxyInterface: Send + Sync {
    type GetHealthStateResponseFut: std::future::Future<Output = Result<HealthState, fidl::Error>>
        + Send;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut;
    fn r#signal_processing_connect(
        &self,
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type ResetResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#reset(&self) -> Self::ResetResponseFut;
    type GetPropertiesResponseFut: std::future::Future<Output = Result<CodecProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type StopResponseFut: std::future::Future<Output = Result<i64, fidl::Error>> + Send;
    fn r#stop(&self) -> Self::StopResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<i64, fidl::Error>> + Send;
    fn r#start(&self) -> Self::StartResponseFut;
    type GetDaiFormatsResponseFut: std::future::Future<Output = Result<CodecGetDaiFormatsResult, fidl::Error>>
        + Send;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut;
    type SetDaiFormatResponseFut: std::future::Future<Output = Result<CodecSetDaiFormatResult, fidl::Error>>
        + Send;
    fn r#set_dai_format(&self, format: &DaiFormat) -> Self::SetDaiFormatResponseFut;
    type WatchPlugStateResponseFut: std::future::Future<Output = Result<PlugState, fidl::Error>>
        + Send;
    fn r#watch_plug_state(&self) -> Self::WatchPlugStateResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CodecProxy {
    type Protocol = CodecMarker;

    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 CodecProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Codec.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <CodecMarker 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) -> CodecEventStream {
        CodecEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    pub fn r#get_health_state(
        &self,
    ) -> fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>
    {
        CodecProxyInterface::r#get_health_state(self)
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        CodecProxyInterface::r#signal_processing_connect(self, protocol)
    }

    /// Resets the codec.
    /// `Reset` returns when the reset is completed. If the driver can't successfully reset the
    /// codec it will close the codec protocol channel, in this case the client may obtain a new
    /// codec protocol channel and retry.
    pub fn r#reset(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        CodecProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<CodecProperties, fdomain_client::fidl::FDomainResourceDialect>
    {
        CodecProxyInterface::r#get_properties(self)
    }

    /// Stops the codec operation.
    /// `Stop` returns when configuring the codec to stop is completed. This method does not wait
    /// for the hardware to actually stop playback/capture (i.e. `turn_off_delay` impact is not
    /// taken into account), nor is any such delay reflected in the returned `stop_time`.
    /// `stop_time` indicates when the driver finished configuring the codec to stop, as measured
    /// in the CLOCK_MONOTONIC timeline.
    /// If the driver cannot successfully configure the codec to stop, it will close the codec
    /// protocol channel, in which case the client may obtain a new codec protocol channel and retry.
    pub fn r#stop(
        &self,
    ) -> fidl::client::QueryResponseFut<i64, fdomain_client::fidl::FDomainResourceDialect> {
        CodecProxyInterface::r#stop(self)
    }

    /// Start/Re-start the codec operation.
    /// `Start` returns when configuring the codec to start is completed. This method does not wait
    /// for the hardware to actually start playback/capture (i.e. `turn_on_delay` impact is not taken
    /// into account), nor is any such delay reflected in the returned `start_time`.
    /// `start_time` indicates when the driver finished configuring the codec to start, as measured
    /// in the CLOCK_MONOTONIC timeline.
    /// If the driver can't successfully start the codec, it will close the codec protocol channel,
    /// in which case the client may obtain a new codec protocol channel and retry.
    pub fn r#start(
        &self,
    ) -> fidl::client::QueryResponseFut<i64, fdomain_client::fidl::FDomainResourceDialect> {
        CodecProxyInterface::r#start(self)
    }

    /// Retrieves the DAI formats supported by the codec, if not available at the time the codec
    /// may reply with an error status and the controller may retry at a later time.
    /// Retrieving multiple DaiSupportedFormats allows for cases where exclusive
    /// combinations of the parameters in DaiSupportedFormats may be supported.
    pub fn r#get_dai_formats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        CodecGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CodecProxyInterface::r#get_dai_formats(self)
    }

    /// Sets the DAI format to be used in the interface between the controller and codec.
    /// Returns an error if not supported at the time of the request (e.g. for removable hardware).
    pub fn r#set_dai_format(
        &self,
        mut format: &DaiFormat,
    ) -> fidl::client::QueryResponseFut<
        CodecSetDaiFormatResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CodecProxyInterface::r#set_dai_format(self, format)
    }

    /// Get the plug detect state via a hanging get. The driver will reply to the first
    /// `WatchPlugState` sent by the client. The driver will not respond to subsequent client
    /// `WatchPlugState` calls until the plug state changes from what was most recently reported.
    pub fn r#watch_plug_state(
        &self,
    ) -> fidl::client::QueryResponseFut<PlugState, fdomain_client::fidl::FDomainResourceDialect>
    {
        CodecProxyInterface::r#watch_plug_state(self)
    }
}

impl CodecProxyInterface for CodecProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e146d6bca733a84,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HealthState>(
            (),
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

    type GetDaiFormatsResponseFut = fidl::client::QueryResponseFut<
        CodecGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecGetDaiFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecGetDaiFormatsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xf8bbc46b4ba6a52,
            >(_buf?)?;
            Ok(_response.map(|x| x.formats))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, CodecGetDaiFormatsResult>(
            (),
            0xf8bbc46b4ba6a52,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetDaiFormatResponseFut = fidl::client::QueryResponseFut<
        CodecSetDaiFormatResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_dai_format(&self, mut format: &DaiFormat) -> Self::SetDaiFormatResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecSetDaiFormatResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecSetDaiFormatResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2f829df9e5a7a1ea,
            >(_buf?)?;
            Ok(_response.map(|x| x.state))
        }
        self.client.send_query_and_decode::<CodecSetDaiFormatRequest, CodecSetDaiFormatResult>(
            (format,),
            0x2f829df9e5a7a1ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CodecRequestStream {
    type Protocol = CodecMarker;
    type ControlHandle = CodecControlHandle;

    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 {
        CodecControlHandle { 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 CodecRequestStream {
    type Item = Result<CodecRequest, 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 CodecRequestStream 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 {
                    0x4e146d6bca733a84 => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::GetHealthState {
                            responder: CodecGetHealthStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa81907ce6066295 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::SignalProcessingConnect {
                            protocol: req.protocol,

                            control_handle,
                        })
                    }
                    0x50757ae579a7bd6b => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::Reset {
                            responder: CodecResetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a0d138a6a1d9d90 => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::GetProperties {
                            responder: CodecGetPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5c2e380df1332dbd => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::Stop {
                            responder: CodecStopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x329cdacb286ab00 => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::Start {
                            responder: CodecStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xf8bbc46b4ba6a52 => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::GetDaiFormats {
                            responder: CodecGetDaiFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f829df9e5a7a1ea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CodecSetDaiFormatRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CodecSetDaiFormatRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::SetDaiFormat {
                            format: req.format,

                            responder: CodecSetDaiFormatResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x182b87f935ca7326 => {
                        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 = CodecControlHandle { inner: this.inner.clone() };
                        Ok(CodecRequest::WatchPlugState {
                            responder: CodecWatchPlugStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CodecMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview see
/// [[Audio Codec Interface]](https://fuchsia.dev/fuchsia-src/development/audio/drivers/codec).
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one DAI and no Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum CodecRequest {
    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    GetHealthState { responder: CodecGetHealthStateResponder },
    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    SignalProcessingConnect {
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        control_handle: CodecControlHandle,
    },
    /// Resets the codec.
    /// `Reset` returns when the reset is completed. If the driver can't successfully reset the
    /// codec it will close the codec protocol channel, in this case the client may obtain a new
    /// codec protocol channel and retry.
    Reset { responder: CodecResetResponder },
    /// Retrieves top level static properties.
    GetProperties { responder: CodecGetPropertiesResponder },
    /// Stops the codec operation.
    /// `Stop` returns when configuring the codec to stop is completed. This method does not wait
    /// for the hardware to actually stop playback/capture (i.e. `turn_off_delay` impact is not
    /// taken into account), nor is any such delay reflected in the returned `stop_time`.
    /// `stop_time` indicates when the driver finished configuring the codec to stop, as measured
    /// in the CLOCK_MONOTONIC timeline.
    /// If the driver cannot successfully configure the codec to stop, it will close the codec
    /// protocol channel, in which case the client may obtain a new codec protocol channel and retry.
    Stop { responder: CodecStopResponder },
    /// Start/Re-start the codec operation.
    /// `Start` returns when configuring the codec to start is completed. This method does not wait
    /// for the hardware to actually start playback/capture (i.e. `turn_on_delay` impact is not taken
    /// into account), nor is any such delay reflected in the returned `start_time`.
    /// `start_time` indicates when the driver finished configuring the codec to start, as measured
    /// in the CLOCK_MONOTONIC timeline.
    /// If the driver can't successfully start the codec, it will close the codec protocol channel,
    /// in which case the client may obtain a new codec protocol channel and retry.
    Start { responder: CodecStartResponder },
    /// Retrieves the DAI formats supported by the codec, if not available at the time the codec
    /// may reply with an error status and the controller may retry at a later time.
    /// Retrieving multiple DaiSupportedFormats allows for cases where exclusive
    /// combinations of the parameters in DaiSupportedFormats may be supported.
    GetDaiFormats { responder: CodecGetDaiFormatsResponder },
    /// Sets the DAI format to be used in the interface between the controller and codec.
    /// Returns an error if not supported at the time of the request (e.g. for removable hardware).
    SetDaiFormat { format: DaiFormat, responder: CodecSetDaiFormatResponder },
    /// Get the plug detect state via a hanging get. The driver will reply to the first
    /// `WatchPlugState` sent by the client. The driver will not respond to subsequent client
    /// `WatchPlugState` calls until the plug state changes from what was most recently reported.
    WatchPlugState { responder: CodecWatchPlugStateResponder },
}

impl CodecRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_health_state(self) -> Option<(CodecGetHealthStateResponder)> {
        if let CodecRequest::GetHealthState { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_processing_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        CodecControlHandle,
    )> {
        if let CodecRequest::SignalProcessingConnect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset(self) -> Option<(CodecResetResponder)> {
        if let CodecRequest::Reset { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(CodecGetPropertiesResponder)> {
        if let CodecRequest::GetProperties { responder } = self { Some((responder)) } else { None }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(CodecStartResponder)> {
        if let CodecRequest::Start { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_dai_formats(self) -> Option<(CodecGetDaiFormatsResponder)> {
        if let CodecRequest::GetDaiFormats { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_dai_format(self) -> Option<(DaiFormat, CodecSetDaiFormatResponder)> {
        if let CodecRequest::SetDaiFormat { format, responder } = self {
            Some((format, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_plug_state(self) -> Option<(CodecWatchPlugStateResponder)> {
        if let CodecRequest::WatchPlugState { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CodecRequest::GetHealthState { .. } => "get_health_state",
            CodecRequest::SignalProcessingConnect { .. } => "signal_processing_connect",
            CodecRequest::Reset { .. } => "reset",
            CodecRequest::GetProperties { .. } => "get_properties",
            CodecRequest::Stop { .. } => "stop",
            CodecRequest::Start { .. } => "start",
            CodecRequest::GetDaiFormats { .. } => "get_dai_formats",
            CodecRequest::SetDaiFormat { .. } => "set_dai_format",
            CodecRequest::WatchPlugState { .. } => "watch_plug_state",
        }
    }
}

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

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

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

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

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

impl CodecControlHandle {}

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

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

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

    fn send_raw(&self, mut state: &HealthState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HealthGetHealthStateResponse>(
            (state,),
            self.tx_id,
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut properties: &CodecProperties) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CodecGetPropertiesResponse>(
            (properties,),
            self.tx_id,
            0x7a0d138a6a1d9d90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut stop_time: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CodecStopResponse>(
            (stop_time,),
            self.tx_id,
            0x5c2e380df1332dbd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut start_time: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CodecStartResponse>(
            (start_time,),
            self.tx_id,
            0x329cdacb286ab00,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[DaiSupportedFormats], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<CodecGetDaiFormatsResponse, i32>>(
                result.map(|formats| (formats,)),
                self.tx_id,
                0xf8bbc46b4ba6a52,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&CodecFormatInfo, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<CodecSetDaiFormatResponse, i32>>(
                result.map(|state| (state,)),
                self.tx_id,
                0x2f829df9e5a7a1ea,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(&self, mut plug_state: &PlugState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CodecWatchPlugStateResponse>(
            (plug_state,),
            self.tx_id,
            0x182b87f935ca7326,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for CodecConnectorMarker {
    type Proxy = CodecConnectorProxy;
    type RequestStream = CodecConnectorRequestStream;

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

pub trait CodecConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        codec_protocol: fdomain_client::fidl::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for CodecConnectorProxy {
    type Protocol = CodecConnectorMarker;

    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 CodecConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/CodecConnector.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <CodecConnectorMarker 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) -> CodecConnectorEventStream {
        CodecConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect to a Codec protocol server.
    /// This indirection into the Codec protocol allows us to support independent codec client
    /// connections.
    pub fn r#connect(
        &self,
        mut codec_protocol: fdomain_client::fidl::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error> {
        CodecConnectorProxyInterface::r#connect(self, codec_protocol)
    }
}

impl CodecConnectorProxyInterface for CodecConnectorProxy {
    fn r#connect(
        &self,
        mut codec_protocol: fdomain_client::fidl::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CodecConnectorConnectRequest>(
            (codec_protocol,),
            0x1413f551544026c9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CodecConnectorRequestStream {
    type Protocol = CodecConnectorMarker;
    type ControlHandle = CodecConnectorControlHandle;

    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 {
        CodecConnectorControlHandle { 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 CodecConnectorRequestStream {
    type Item = Result<CodecConnectorRequest, 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 CodecConnectorRequestStream 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 {
                0x1413f551544026c9 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CodecConnectorConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CodecConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CodecConnectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CodecConnectorRequest::Connect {codec_protocol: req.codec_protocol,

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

/// For an overview of the Codec protocols see
/// [Codec Interface](//docs/development/audio/drivers/codec.md)
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one DAI and no Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum CodecConnectorRequest {
    /// Connect to a Codec protocol server.
    /// This indirection into the Codec protocol allows us to support independent codec client
    /// connections.
    Connect {
        codec_protocol: fdomain_client::fidl::ServerEnd<CodecMarker>,
        control_handle: CodecConnectorControlHandle,
    },
}

impl CodecConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<CodecMarker>, CodecConnectorControlHandle)> {
        if let CodecConnectorRequest::Connect { codec_protocol, control_handle } = self {
            Some((codec_protocol, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl CodecConnectorControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for CompositeMarker {
    type Proxy = CompositeProxy;
    type RequestStream = CompositeRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Composite";
}
pub type CompositeResetResult = Result<(), DriverError>;
pub type CompositeGetRingBufferFormatsResult = Result<Vec<SupportedFormats2>, DriverError>;
pub type CompositeCreateRingBufferResult = Result<(), DriverError>;
pub type CompositeGetDaiFormatsResult = Result<Vec<DaiSupportedFormats>, DriverError>;
pub type CompositeSetDaiFormatResult = Result<(), DriverError>;
pub type CompositeGetPacketStreamFormatsResult = Result<Vec<SupportedFormats2>, DriverError>;
pub type CompositeCreatePacketStreamResult = Result<(), DriverError>;

pub trait CompositeProxyInterface: Send + Sync {
    type GetHealthStateResponseFut: std::future::Future<Output = Result<HealthState, fidl::Error>>
        + Send;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut;
    fn r#signal_processing_connect(
        &self,
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type ResetResponseFut: std::future::Future<Output = Result<CompositeResetResult, fidl::Error>>
        + Send;
    fn r#reset(&self) -> Self::ResetResponseFut;
    type GetPropertiesResponseFut: std::future::Future<Output = Result<CompositeProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type GetRingBufferFormatsResponseFut: std::future::Future<Output = Result<CompositeGetRingBufferFormatsResult, fidl::Error>>
        + Send;
    fn r#get_ring_buffer_formats(
        &self,
        processing_element_id: u64,
    ) -> Self::GetRingBufferFormatsResponseFut;
    type CreateRingBufferResponseFut: std::future::Future<Output = Result<CompositeCreateRingBufferResult, fidl::Error>>
        + Send;
    fn r#create_ring_buffer(
        &self,
        processing_element_id: u64,
        format: &Format2,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Self::CreateRingBufferResponseFut;
    type GetDaiFormatsResponseFut: std::future::Future<Output = Result<CompositeGetDaiFormatsResult, fidl::Error>>
        + Send;
    fn r#get_dai_formats(&self, processing_element_id: u64) -> Self::GetDaiFormatsResponseFut;
    type SetDaiFormatResponseFut: std::future::Future<Output = Result<CompositeSetDaiFormatResult, fidl::Error>>
        + Send;
    fn r#set_dai_format(
        &self,
        processing_element_id: u64,
        format: &DaiFormat,
    ) -> Self::SetDaiFormatResponseFut;
    type GetPacketStreamFormatsResponseFut: std::future::Future<Output = Result<CompositeGetPacketStreamFormatsResult, fidl::Error>>
        + Send;
    fn r#get_packet_stream_formats(
        &self,
        processing_element_id: u64,
    ) -> Self::GetPacketStreamFormatsResponseFut;
    type CreatePacketStreamResponseFut: std::future::Future<Output = Result<CompositeCreatePacketStreamResult, fidl::Error>>
        + Send;
    fn r#create_packet_stream(
        &self,
        processing_element_id: u64,
        format: &Format2,
        packet_stream_control: fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
    ) -> Self::CreatePacketStreamResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CompositeProxy {
    type Protocol = CompositeMarker;

    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 CompositeProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Composite.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <CompositeMarker 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) -> CompositeEventStream {
        CompositeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    pub fn r#get_health_state(
        &self,
    ) -> fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>
    {
        CompositeProxyInterface::r#get_health_state(self)
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        CompositeProxyInterface::r#signal_processing_connect(self, protocol)
    }

    /// Resets the hardware including all DAI interconnects and signal processing.
    /// As a result, all channels obtained by `CreateRingBuffer` or `CreatePacketStream` will be
    /// closed.
    ///
    /// `Reset` returns when the hardware is fully reset. At this point, a client would need to
    /// reconfigure any DAI interconnects, select a signal processing topology and reconfigure
    /// any processing elements, and reconstruct any ring buffers and packet streams.
    ///
    /// If the driver can't successfully reset the hardware, it will return an error and then close
    /// the protocol channel, in this case the client may obtain a new protocol channel and retry.
    pub fn r#reset(
        &self,
    ) -> fidl::client::QueryResponseFut<
        CompositeResetResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        CompositeProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#get_properties(self)
    }

    /// Retrieves the ring buffer formats supported by a `RING_BUFFER` processing element
    /// in the topology supported by this driver as returned by `GetElements` from
    /// fuchsia.hardware.audio.signalprocessing.
    /// Returns `SHOULD_WAIT` if the ring buffer formats are not available at the time, the
    /// client may retry at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `RING_BUFFER`.
    /// Retrieving multiple `SupportedFormats2` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats2` may be supported.
    /// The vector returned to the caller must contain at least one entry.
    pub fn r#get_ring_buffer_formats(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<
        CompositeGetRingBufferFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#get_ring_buffer_formats(self, processing_element_id)
    }

    /// `CreateRingBuffer` is sent by clients to select a ring buffer format for the `RING_BUFFER`
    /// processing element specified by `processing_element_id`. The format is based on information
    /// that the driver provides in `GetRingBufferFormats`, what is supported by the client, and
    /// any other requirement. The returned `ring_buffer` channel is used to access and control the
    /// audio buffer provided by the driver.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `RING_BUFFER`.
    /// Returns `NOT_SUPPORTED` if the driver does not support ring buffers, or if the specified
    /// `format` is not supported.
    pub fn r#create_ring_buffer(
        &self,
        mut processing_element_id: u64,
        mut format: &Format2,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> fidl::client::QueryResponseFut<
        CompositeCreateRingBufferResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#create_ring_buffer(
            self,
            processing_element_id,
            format,
            ring_buffer,
        )
    }

    /// Retrieves the DAI formats supported by a `DAI_INTERCONNECT` processing element
    /// in the topology supported by this driver as returned by `GetElements` from
    /// fuchsia.hardware.audio.signalprocessing.
    /// Returns `SHOULD_WAIT` if the DAI formats are not available at the time, the client
    /// may retry at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `DAI_INTERCONNECT`.
    /// Retrieving multiple `DaiSupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in DaiSupportedFormats may be supported.
    /// The vector returned to the caller must contain at least one entry.
    pub fn r#get_dai_formats(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<
        CompositeGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#get_dai_formats(self, processing_element_id)
    }

    /// `SetDaiFormat` is sent by clients to select a DAI format for the `DAI_INTERCONNECT`
    /// processing element specified by `processing_element_id`. The format is based on information
    /// that the driver provides in `GetDaiFormats`, what is supported by the client, and any other
    /// requirement.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `DAI_INTERCONNECT`.
    pub fn r#set_dai_format(
        &self,
        mut processing_element_id: u64,
        mut format: &DaiFormat,
    ) -> fidl::client::QueryResponseFut<
        CompositeSetDaiFormatResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#set_dai_format(self, processing_element_id, format)
    }

    /// Retrieves the packet-stream formats supported by a `PACKET_STREAM` processing element
    /// in the topologies supported by this driver, as returned by `GetElements` and `GetTopologies`
    /// from fuchsia.hardware.audio.signalprocessing.
    ///
    /// Returns `SHOULD_WAIT` if the packet-stream formats are not available at this time. The
    /// client may retry this request at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned by
    /// `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `PACKET_STREAM`.
    /// Returns `NOT_SUPPORTED` if the driver does not support packet streams.
    /// Returning a vector with multiple `SupportedFormats2` enables cases where exclusive
    /// combinations of the parameters in `SupportedFormats2` may be supported.
    /// The vector returned to the caller must contain at least one entry.
    pub fn r#get_packet_stream_formats(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<
        CompositeGetPacketStreamFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#get_packet_stream_formats(self, processing_element_id)
    }

    /// `CreatePacketStream` is sent by clients to select a packet-stream format for the
    /// `PACKET_STREAM` processing element specified by `processing_element_id`. The format is
    /// based on information that the driver provides in `GetPacketStreamFormats`, what is
    /// supported by the client, and any other requirement. The returned `packet_stream_control`
    /// channel is used to access and control the packet stream protocol served by the driver.
    ///
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned by
    /// `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `PACKET_STREAM`.
    /// Returns `SHOULD_WAIT` if the server cannot create a packet stream for this element/format
    /// at this time, but it should be able to at some future time. This request can be retried.
    /// Returns `NOT_SUPPORTED` if the driver does not support packet streams, or if the specified
    /// `format` is not supported.
    pub fn r#create_packet_stream(
        &self,
        mut processing_element_id: u64,
        mut format: &Format2,
        mut packet_stream_control: fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
    ) -> fidl::client::QueryResponseFut<
        CompositeCreatePacketStreamResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CompositeProxyInterface::r#create_packet_stream(
            self,
            processing_element_id,
            format,
            packet_stream_control,
        )
    }
}

impl CompositeProxyInterface for CompositeProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e146d6bca733a84,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HealthState>(
            (),
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ResetResponseFut = fidl::client::QueryResponseFut<
        CompositeResetResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#reset(&self) -> Self::ResetResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeResetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, DriverError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xac355fb98341996,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("reset")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, CompositeResetResult>(
            (),
            0xac355fb98341996,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetPropertiesResponseFut = fidl::client::QueryResponseFut<
        CompositeProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<CompositeGetPropertiesResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x31846fa0a459942b,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("get_properties")?;
            Ok(_response.properties)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, CompositeProperties>(
            (),
            0x31846fa0a459942b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetRingBufferFormatsResponseFut = fidl::client::QueryResponseFut<
        CompositeGetRingBufferFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_ring_buffer_formats(
        &self,
        mut processing_element_id: u64,
    ) -> Self::GetRingBufferFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeGetRingBufferFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    CompositeGetRingBufferFormatsResponse,
                    DriverError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1d89b701b6816ac4,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("get_ring_buffer_formats")?;
            Ok(_response.map(|x| x.ring_buffer_formats))
        }
        self.client.send_query_and_decode::<
            CompositeGetRingBufferFormatsRequest,
            CompositeGetRingBufferFormatsResult,
        >(
            (processing_element_id,),
            0x1d89b701b6816ac4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CreateRingBufferResponseFut = fidl::client::QueryResponseFut<
        CompositeCreateRingBufferResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_ring_buffer(
        &self,
        mut processing_element_id: u64,
        mut format: &Format2,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Self::CreateRingBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeCreateRingBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, DriverError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x28c5685f85262033,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("create_ring_buffer")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CompositeCreateRingBufferRequest,
            CompositeCreateRingBufferResult,
        >(
            (processing_element_id, format, ring_buffer,),
            0x28c5685f85262033,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetDaiFormatsResponseFut = fidl::client::QueryResponseFut<
        CompositeGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_dai_formats(&self, mut processing_element_id: u64) -> Self::GetDaiFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeGetDaiFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<CompositeGetDaiFormatsResponse, DriverError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3cbeaed59c8f69b,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("get_dai_formats")?;
            Ok(_response.map(|x| x.dai_formats))
        }
        self.client
            .send_query_and_decode::<CompositeGetDaiFormatsRequest, CompositeGetDaiFormatsResult>(
                (processing_element_id,),
                0x3cbeaed59c8f69b,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type SetDaiFormatResponseFut = fidl::client::QueryResponseFut<
        CompositeSetDaiFormatResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_dai_format(
        &self,
        mut processing_element_id: u64,
        mut format: &DaiFormat,
    ) -> Self::SetDaiFormatResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeSetDaiFormatResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, DriverError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x155acf5cc0dc8a84,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("set_dai_format")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<CompositeSetDaiFormatRequest, CompositeSetDaiFormatResult>(
                (processing_element_id, format),
                0x155acf5cc0dc8a84,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type GetPacketStreamFormatsResponseFut = fidl::client::QueryResponseFut<
        CompositeGetPacketStreamFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_packet_stream_formats(
        &self,
        mut processing_element_id: u64,
    ) -> Self::GetPacketStreamFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeGetPacketStreamFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    CompositeGetPacketStreamFormatsResponse,
                    DriverError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x73cc47c6ad39bca7,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("get_packet_stream_formats")?;
            Ok(_response.map(|x| x.packet_stream_formats))
        }
        self.client.send_query_and_decode::<
            CompositeGetPacketStreamFormatsRequest,
            CompositeGetPacketStreamFormatsResult,
        >(
            (processing_element_id,),
            0x73cc47c6ad39bca7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CreatePacketStreamResponseFut = fidl::client::QueryResponseFut<
        CompositeCreatePacketStreamResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_packet_stream(
        &self,
        mut processing_element_id: u64,
        mut format: &Format2,
        mut packet_stream_control: fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
    ) -> Self::CreatePacketStreamResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CompositeCreatePacketStreamResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, DriverError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x50e8902b756c707c,
            >(_buf?)?
            .into_result_fdomain::<CompositeMarker>("create_packet_stream")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CompositeCreatePacketStreamRequest,
            CompositeCreatePacketStreamResult,
        >(
            (processing_element_id, format, packet_stream_control,),
            0x50e8902b756c707c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CompositeRequestStream {
    type Protocol = CompositeMarker;
    type ControlHandle = CompositeControlHandle;

    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 {
        CompositeControlHandle { 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 CompositeRequestStream {
    type Item = Result<CompositeRequest, 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 CompositeRequestStream 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 {
                    0x4e146d6bca733a84 => {
                        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 = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::GetHealthState {
                            responder: CompositeGetHealthStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa81907ce6066295 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::SignalProcessingConnect {
                            protocol: req.protocol,

                            control_handle,
                        })
                    }
                    0xac355fb98341996 => {
                        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 = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::Reset {
                            responder: CompositeResetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31846fa0a459942b => {
                        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 = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::GetProperties {
                            responder: CompositeGetPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1d89b701b6816ac4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeGetRingBufferFormatsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeGetRingBufferFormatsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::GetRingBufferFormats {
                            processing_element_id: req.processing_element_id,

                            responder: CompositeGetRingBufferFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x28c5685f85262033 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeCreateRingBufferRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeCreateRingBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::CreateRingBuffer {
                            processing_element_id: req.processing_element_id,
                            format: req.format,
                            ring_buffer: req.ring_buffer,

                            responder: CompositeCreateRingBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3cbeaed59c8f69b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeGetDaiFormatsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeGetDaiFormatsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::GetDaiFormats {
                            processing_element_id: req.processing_element_id,

                            responder: CompositeGetDaiFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x155acf5cc0dc8a84 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeSetDaiFormatRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeSetDaiFormatRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::SetDaiFormat {
                            processing_element_id: req.processing_element_id,
                            format: req.format,

                            responder: CompositeSetDaiFormatResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x73cc47c6ad39bca7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeGetPacketStreamFormatsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeGetPacketStreamFormatsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::GetPacketStreamFormats {
                            processing_element_id: req.processing_element_id,

                            responder: CompositeGetPacketStreamFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x50e8902b756c707c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CompositeCreatePacketStreamRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeCreatePacketStreamRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CompositeControlHandle { inner: this.inner.clone() };
                        Ok(CompositeRequest::CreatePacketStream {
                            processing_element_id: req.processing_element_id,
                            format: req.format,
                            packet_stream_control: req.packet_stream_control,

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

#[derive(Debug)]
pub enum CompositeRequest {
    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    GetHealthState { responder: CompositeGetHealthStateResponder },
    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    SignalProcessingConnect {
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        control_handle: CompositeControlHandle,
    },
    /// Resets the hardware including all DAI interconnects and signal processing.
    /// As a result, all channels obtained by `CreateRingBuffer` or `CreatePacketStream` will be
    /// closed.
    ///
    /// `Reset` returns when the hardware is fully reset. At this point, a client would need to
    /// reconfigure any DAI interconnects, select a signal processing topology and reconfigure
    /// any processing elements, and reconstruct any ring buffers and packet streams.
    ///
    /// If the driver can't successfully reset the hardware, it will return an error and then close
    /// the protocol channel, in this case the client may obtain a new protocol channel and retry.
    Reset { responder: CompositeResetResponder },
    /// Retrieves top level static properties.
    GetProperties { responder: CompositeGetPropertiesResponder },
    /// Retrieves the ring buffer formats supported by a `RING_BUFFER` processing element
    /// in the topology supported by this driver as returned by `GetElements` from
    /// fuchsia.hardware.audio.signalprocessing.
    /// Returns `SHOULD_WAIT` if the ring buffer formats are not available at the time, the
    /// client may retry at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `RING_BUFFER`.
    /// Retrieving multiple `SupportedFormats2` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats2` may be supported.
    /// The vector returned to the caller must contain at least one entry.
    GetRingBufferFormats {
        processing_element_id: u64,
        responder: CompositeGetRingBufferFormatsResponder,
    },
    /// `CreateRingBuffer` is sent by clients to select a ring buffer format for the `RING_BUFFER`
    /// processing element specified by `processing_element_id`. The format is based on information
    /// that the driver provides in `GetRingBufferFormats`, what is supported by the client, and
    /// any other requirement. The returned `ring_buffer` channel is used to access and control the
    /// audio buffer provided by the driver.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `RING_BUFFER`.
    /// Returns `NOT_SUPPORTED` if the driver does not support ring buffers, or if the specified
    /// `format` is not supported.
    CreateRingBuffer {
        processing_element_id: u64,
        format: Format2,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        responder: CompositeCreateRingBufferResponder,
    },
    /// Retrieves the DAI formats supported by a `DAI_INTERCONNECT` processing element
    /// in the topology supported by this driver as returned by `GetElements` from
    /// fuchsia.hardware.audio.signalprocessing.
    /// Returns `SHOULD_WAIT` if the DAI formats are not available at the time, the client
    /// may retry at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `DAI_INTERCONNECT`.
    /// Retrieving multiple `DaiSupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in DaiSupportedFormats may be supported.
    /// The vector returned to the caller must contain at least one entry.
    GetDaiFormats { processing_element_id: u64, responder: CompositeGetDaiFormatsResponder },
    /// `SetDaiFormat` is sent by clients to select a DAI format for the `DAI_INTERCONNECT`
    /// processing element specified by `processing_element_id`. The format is based on information
    /// that the driver provides in `GetDaiFormats`, what is supported by the client, and any other
    /// requirement.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned
    /// by `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `DAI_INTERCONNECT`.
    SetDaiFormat {
        processing_element_id: u64,
        format: DaiFormat,
        responder: CompositeSetDaiFormatResponder,
    },
    /// Retrieves the packet-stream formats supported by a `PACKET_STREAM` processing element
    /// in the topologies supported by this driver, as returned by `GetElements` and `GetTopologies`
    /// from fuchsia.hardware.audio.signalprocessing.
    ///
    /// Returns `SHOULD_WAIT` if the packet-stream formats are not available at this time. The
    /// client may retry this request at a later time.
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned by
    /// `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `PACKET_STREAM`.
    /// Returns `NOT_SUPPORTED` if the driver does not support packet streams.
    /// Returning a vector with multiple `SupportedFormats2` enables cases where exclusive
    /// combinations of the parameters in `SupportedFormats2` may be supported.
    /// The vector returned to the caller must contain at least one entry.
    GetPacketStreamFormats {
        processing_element_id: u64,
        responder: CompositeGetPacketStreamFormatsResponder,
    },
    /// `CreatePacketStream` is sent by clients to select a packet-stream format for the
    /// `PACKET_STREAM` processing element specified by `processing_element_id`. The format is
    /// based on information that the driver provides in `GetPacketStreamFormats`, what is
    /// supported by the client, and any other requirement. The returned `packet_stream_control`
    /// channel is used to access and control the packet stream protocol served by the driver.
    ///
    /// Returns `INVALID_ARGS` if the `processing_element_id` does not match an id returned by
    /// `GetElements`.
    /// Returns `WRONG_TYPE` if the `ElementType` of the element represented by the id is not
    /// `PACKET_STREAM`.
    /// Returns `SHOULD_WAIT` if the server cannot create a packet stream for this element/format
    /// at this time, but it should be able to at some future time. This request can be retried.
    /// Returns `NOT_SUPPORTED` if the driver does not support packet streams, or if the specified
    /// `format` is not supported.
    CreatePacketStream {
        processing_element_id: u64,
        format: Format2,
        packet_stream_control: fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
        responder: CompositeCreatePacketStreamResponder,
    },
    /// 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: CompositeControlHandle,
        method_type: fidl::MethodType,
    },
}

impl CompositeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_health_state(self) -> Option<(CompositeGetHealthStateResponder)> {
        if let CompositeRequest::GetHealthState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_processing_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        CompositeControlHandle,
    )> {
        if let CompositeRequest::SignalProcessingConnect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset(self) -> Option<(CompositeResetResponder)> {
        if let CompositeRequest::Reset { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(CompositeGetPropertiesResponder)> {
        if let CompositeRequest::GetProperties { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ring_buffer_formats(
        self,
    ) -> Option<(u64, CompositeGetRingBufferFormatsResponder)> {
        if let CompositeRequest::GetRingBufferFormats { processing_element_id, responder } = self {
            Some((processing_element_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_ring_buffer(
        self,
    ) -> Option<(
        u64,
        Format2,
        fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        CompositeCreateRingBufferResponder,
    )> {
        if let CompositeRequest::CreateRingBuffer {
            processing_element_id,
            format,
            ring_buffer,
            responder,
        } = self
        {
            Some((processing_element_id, format, ring_buffer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_dai_formats(self) -> Option<(u64, CompositeGetDaiFormatsResponder)> {
        if let CompositeRequest::GetDaiFormats { processing_element_id, responder } = self {
            Some((processing_element_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_dai_format(self) -> Option<(u64, DaiFormat, CompositeSetDaiFormatResponder)> {
        if let CompositeRequest::SetDaiFormat { processing_element_id, format, responder } = self {
            Some((processing_element_id, format, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_packet_stream_formats(
        self,
    ) -> Option<(u64, CompositeGetPacketStreamFormatsResponder)> {
        if let CompositeRequest::GetPacketStreamFormats { processing_element_id, responder } = self
        {
            Some((processing_element_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_packet_stream(
        self,
    ) -> Option<(
        u64,
        Format2,
        fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
        CompositeCreatePacketStreamResponder,
    )> {
        if let CompositeRequest::CreatePacketStream {
            processing_element_id,
            format,
            packet_stream_control,
            responder,
        } = self
        {
            Some((processing_element_id, format, packet_stream_control, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CompositeRequest::GetHealthState { .. } => "get_health_state",
            CompositeRequest::SignalProcessingConnect { .. } => "signal_processing_connect",
            CompositeRequest::Reset { .. } => "reset",
            CompositeRequest::GetProperties { .. } => "get_properties",
            CompositeRequest::GetRingBufferFormats { .. } => "get_ring_buffer_formats",
            CompositeRequest::CreateRingBuffer { .. } => "create_ring_buffer",
            CompositeRequest::GetDaiFormats { .. } => "get_dai_formats",
            CompositeRequest::SetDaiFormat { .. } => "set_dai_format",
            CompositeRequest::GetPacketStreamFormats { .. } => "get_packet_stream_formats",
            CompositeRequest::CreatePacketStream { .. } => "create_packet_stream",
            CompositeRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            CompositeRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl CompositeControlHandle {}

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

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

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

    fn send_raw(&self, mut state: &HealthState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HealthGetHealthStateResponse>(
            (state,),
            self.tx_id,
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut properties: &CompositeProperties) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<CompositeGetPropertiesResponse>>(
                fidl::encoding::Flexible::new((properties,)),
                self.tx_id,
                0x31846fa0a459942b,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&[SupportedFormats2], DriverError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            CompositeGetRingBufferFormatsResponse,
            DriverError,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.map(|ring_buffer_formats| (ring_buffer_formats,)),
            ),
            self.tx_id,
            0x1d89b701b6816ac4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&[DaiSupportedFormats], DriverError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            CompositeGetDaiFormatsResponse,
            DriverError,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|dai_formats| (dai_formats,))),
            self.tx_id,
            0x3cbeaed59c8f69b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&[SupportedFormats2], DriverError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            CompositeGetPacketStreamFormatsResponse,
            DriverError,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.map(|packet_stream_formats| (packet_stream_formats,)),
            ),
            self.tx_id,
            0x73cc47c6ad39bca7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for CompositeConnectorMarker {
    type Proxy = CompositeConnectorProxy;
    type RequestStream = CompositeConnectorRequestStream;

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

pub trait CompositeConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        composite_protocol: fdomain_client::fidl::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for CompositeConnectorProxy {
    type Protocol = CompositeConnectorMarker;

    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 CompositeConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/CompositeConnector.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <CompositeConnectorMarker 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) -> CompositeConnectorEventStream {
        CompositeConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect to a `Composite` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    pub fn r#connect(
        &self,
        mut composite_protocol: fdomain_client::fidl::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error> {
        CompositeConnectorProxyInterface::r#connect(self, composite_protocol)
    }
}

impl CompositeConnectorProxyInterface for CompositeConnectorProxy {
    fn r#connect(
        &self,
        mut composite_protocol: fdomain_client::fidl::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CompositeConnectorConnectRequest>(
            (composite_protocol,),
            0x7ee557529079e466,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CompositeConnectorRequestStream {
    type Protocol = CompositeConnectorMarker;
    type ControlHandle = CompositeConnectorControlHandle;

    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 {
        CompositeConnectorControlHandle { 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 CompositeConnectorRequestStream {
    type Item = Result<CompositeConnectorRequest, 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 CompositeConnectorRequestStream 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 {
                0x7ee557529079e466 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CompositeConnectorConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CompositeConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CompositeConnectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CompositeConnectorRequest::Connect {composite_protocol: req.composite_protocol,

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

/// For an overview see
/// [Audio Composite Devices](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite.md).
#[derive(Debug)]
pub enum CompositeConnectorRequest {
    /// Connect to a `Composite` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    Connect {
        composite_protocol: fdomain_client::fidl::ServerEnd<CompositeMarker>,
        control_handle: CompositeConnectorControlHandle,
    },
}

impl CompositeConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<CompositeMarker>, CompositeConnectorControlHandle)>
    {
        if let CompositeConnectorRequest::Connect { composite_protocol, control_handle } = self {
            Some((composite_protocol, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl CompositeConnectorControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for DaiMarker {
    type Proxy = DaiProxy;
    type RequestStream = DaiRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Dai";
}
pub type DaiGetDaiFormatsResult = Result<Vec<DaiSupportedFormats>, i32>;
pub type DaiGetRingBufferFormatsResult = Result<Vec<SupportedFormats>, i32>;

pub trait DaiProxyInterface: Send + Sync {
    type GetHealthStateResponseFut: std::future::Future<Output = Result<HealthState, fidl::Error>>
        + Send;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut;
    fn r#signal_processing_connect(
        &self,
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type ResetResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#reset(&self) -> Self::ResetResponseFut;
    type GetPropertiesResponseFut: std::future::Future<Output = Result<DaiProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type GetDaiFormatsResponseFut: std::future::Future<Output = Result<DaiGetDaiFormatsResult, fidl::Error>>
        + Send;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut;
    type GetRingBufferFormatsResponseFut: std::future::Future<Output = Result<DaiGetRingBufferFormatsResult, fidl::Error>>
        + Send;
    fn r#get_ring_buffer_formats(&self) -> Self::GetRingBufferFormatsResponseFut;
    fn r#create_ring_buffer(
        &self,
        dai_format: &DaiFormat,
        ring_buffer_format: &Format,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for DaiProxy {
    type Protocol = DaiMarker;

    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 DaiProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Dai.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <DaiMarker 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) -> DaiEventStream {
        DaiEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    pub fn r#get_health_state(
        &self,
    ) -> fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>
    {
        DaiProxyInterface::r#get_health_state(self)
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        DaiProxyInterface::r#signal_processing_connect(self, protocol)
    }

    /// Resets the DAI HW. The `ring_buffer` channel obtained via `CreateRingBuffer` may be closed
    /// by the driver, in this case the client needs to obtain a new `ring_buffer`.
    /// `Reset` returns when the reset is completed. If the driver can't successfully reset the HW,
    /// it will close the DAI protocol channel, in this case the client may obtain a new DAI
    /// protocol channel and retry.
    pub fn r#reset(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        DaiProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<DaiProperties, fdomain_client::fidl::FDomainResourceDialect>
    {
        DaiProxyInterface::r#get_properties(self)
    }

    /// Retrieves the DAI formats supported by the DAI, if not available at the time the DAI
    /// may reply with an error status and the client may retry at a later time.
    /// Retrieving multiple `DaiSupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in SupportedFormats may be supported.
    pub fn r#get_dai_formats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DaiGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DaiProxyInterface::r#get_dai_formats(self)
    }

    /// Retrieves the ring buffer formats supported by the DAI, if not available at the time the DAI
    /// may reply with an error status and the client may retry at a later time.
    /// Retrieving multiple `SupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats` may be supported.
    pub fn r#get_ring_buffer_formats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DaiGetRingBufferFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DaiProxyInterface::r#get_ring_buffer_formats(self)
    }

    /// `CreateRingBuffer` is sent by clients to select both a DAI format and a ring buffer format
    /// based on information that the driver provides in `GetDaiFormats` and `GetRingBufferFormats`,
    /// what is supported by the client, and any other requirement. The `ring_buffer` channel is
    /// used to control the audio buffer, if a previous ring buffer channel had been established and
    /// was still active, the driver must close that (ring buffer) channel and make every attempt to
    /// gracefully quiesce any on-going streaming operations in the process.
    pub fn r#create_ring_buffer(
        &self,
        mut dai_format: &DaiFormat,
        mut ring_buffer_format: &Format,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        DaiProxyInterface::r#create_ring_buffer(self, dai_format, ring_buffer_format, ring_buffer)
    }
}

impl DaiProxyInterface for DaiProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e146d6bca733a84,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HealthState>(
            (),
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    type GetDaiFormatsResponseFut = fidl::client::QueryResponseFut<
        DaiGetDaiFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DaiGetDaiFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DaiGetDaiFormatsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1eb37b0cddf79d69,
            >(_buf?)?;
            Ok(_response.map(|x| x.dai_formats))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DaiGetDaiFormatsResult>(
            (),
            0x1eb37b0cddf79d69,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetRingBufferFormatsResponseFut = fidl::client::QueryResponseFut<
        DaiGetRingBufferFormatsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_ring_buffer_formats(&self) -> Self::GetRingBufferFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DaiGetRingBufferFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DaiGetRingBufferFormatsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x760371081d8c92e4,
            >(_buf?)?;
            Ok(_response.map(|x| x.ring_buffer_formats))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, DaiGetRingBufferFormatsResult>(
                (),
                0x760371081d8c92e4,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#create_ring_buffer(
        &self,
        mut dai_format: &DaiFormat,
        mut ring_buffer_format: &Format,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DaiCreateRingBufferRequest>(
            (dai_format, ring_buffer_format, ring_buffer),
            0x5af9760589a75257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for DaiRequestStream {
    type Protocol = DaiMarker;
    type ControlHandle = DaiControlHandle;

    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 {
        DaiControlHandle { 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 DaiRequestStream {
    type Item = Result<DaiRequest, 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 DaiRequestStream 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 {
                    0x4e146d6bca733a84 => {
                        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 = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::GetHealthState {
                            responder: DaiGetHealthStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa81907ce6066295 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::SignalProcessingConnect {
                            protocol: req.protocol,

                            control_handle,
                        })
                    }
                    0x69e5fa9fa2f78c14 => {
                        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 = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::Reset {
                            responder: DaiResetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c25a1a66149510b => {
                        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 = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::GetProperties {
                            responder: DaiGetPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1eb37b0cddf79d69 => {
                        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 = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::GetDaiFormats {
                            responder: DaiGetDaiFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x760371081d8c92e4 => {
                        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 = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::GetRingBufferFormats {
                            responder: DaiGetRingBufferFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5af9760589a75257 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DaiCreateRingBufferRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DaiCreateRingBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DaiControlHandle { inner: this.inner.clone() };
                        Ok(DaiRequest::CreateRingBuffer {
                            dai_format: req.dai_format,
                            ring_buffer_format: req.ring_buffer_format,
                            ring_buffer: req.ring_buffer,

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

/// For an overview see
/// [Digital Audio Interface](https://fuchsia.dev/fuchsia-src/development/audio/drivers/dai).
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one DAI and one Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum DaiRequest {
    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    GetHealthState { responder: DaiGetHealthStateResponder },
    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    SignalProcessingConnect {
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        control_handle: DaiControlHandle,
    },
    /// Resets the DAI HW. The `ring_buffer` channel obtained via `CreateRingBuffer` may be closed
    /// by the driver, in this case the client needs to obtain a new `ring_buffer`.
    /// `Reset` returns when the reset is completed. If the driver can't successfully reset the HW,
    /// it will close the DAI protocol channel, in this case the client may obtain a new DAI
    /// protocol channel and retry.
    Reset { responder: DaiResetResponder },
    /// Retrieves top level static properties.
    GetProperties { responder: DaiGetPropertiesResponder },
    /// Retrieves the DAI formats supported by the DAI, if not available at the time the DAI
    /// may reply with an error status and the client may retry at a later time.
    /// Retrieving multiple `DaiSupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in SupportedFormats may be supported.
    GetDaiFormats { responder: DaiGetDaiFormatsResponder },
    /// Retrieves the ring buffer formats supported by the DAI, if not available at the time the DAI
    /// may reply with an error status and the client may retry at a later time.
    /// Retrieving multiple `SupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats` may be supported.
    GetRingBufferFormats { responder: DaiGetRingBufferFormatsResponder },
    /// `CreateRingBuffer` is sent by clients to select both a DAI format and a ring buffer format
    /// based on information that the driver provides in `GetDaiFormats` and `GetRingBufferFormats`,
    /// what is supported by the client, and any other requirement. The `ring_buffer` channel is
    /// used to control the audio buffer, if a previous ring buffer channel had been established and
    /// was still active, the driver must close that (ring buffer) channel and make every attempt to
    /// gracefully quiesce any on-going streaming operations in the process.
    CreateRingBuffer {
        dai_format: DaiFormat,
        ring_buffer_format: Format,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        control_handle: DaiControlHandle,
    },
}

impl DaiRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_health_state(self) -> Option<(DaiGetHealthStateResponder)> {
        if let DaiRequest::GetHealthState { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_processing_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        DaiControlHandle,
    )> {
        if let DaiRequest::SignalProcessingConnect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset(self) -> Option<(DaiResetResponder)> {
        if let DaiRequest::Reset { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(DaiGetPropertiesResponder)> {
        if let DaiRequest::GetProperties { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_dai_formats(self) -> Option<(DaiGetDaiFormatsResponder)> {
        if let DaiRequest::GetDaiFormats { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ring_buffer_formats(self) -> Option<(DaiGetRingBufferFormatsResponder)> {
        if let DaiRequest::GetRingBufferFormats { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_ring_buffer(
        self,
    ) -> Option<(
        DaiFormat,
        Format,
        fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        DaiControlHandle,
    )> {
        if let DaiRequest::CreateRingBuffer {
            dai_format,
            ring_buffer_format,
            ring_buffer,
            control_handle,
        } = self
        {
            Some((dai_format, ring_buffer_format, ring_buffer, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DaiRequest::GetHealthState { .. } => "get_health_state",
            DaiRequest::SignalProcessingConnect { .. } => "signal_processing_connect",
            DaiRequest::Reset { .. } => "reset",
            DaiRequest::GetProperties { .. } => "get_properties",
            DaiRequest::GetDaiFormats { .. } => "get_dai_formats",
            DaiRequest::GetRingBufferFormats { .. } => "get_ring_buffer_formats",
            DaiRequest::CreateRingBuffer { .. } => "create_ring_buffer",
        }
    }
}

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

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

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

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

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

impl DaiControlHandle {}

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

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

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

    fn send_raw(&self, mut state: &HealthState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HealthGetHealthStateResponse>(
            (state,),
            self.tx_id,
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut properties: &DaiProperties) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DaiGetPropertiesResponse>(
            (properties,),
            self.tx_id,
            0x2c25a1a66149510b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[DaiSupportedFormats], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<DaiGetDaiFormatsResponse, i32>>(
            result.map(|dai_formats| (dai_formats,)),
            self.tx_id,
            0x1eb37b0cddf79d69,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[SupportedFormats], i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DaiGetRingBufferFormatsResponse, i32>>(
                result.map(|ring_buffer_formats| (ring_buffer_formats,)),
                self.tx_id,
                0x760371081d8c92e4,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for DaiConnectorMarker {
    type Proxy = DaiConnectorProxy;
    type RequestStream = DaiConnectorRequestStream;

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

pub trait DaiConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        dai_protocol: fdomain_client::fidl::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for DaiConnectorProxy {
    type Protocol = DaiConnectorMarker;

    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 DaiConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/DaiConnector.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <DaiConnectorMarker 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) -> DaiConnectorEventStream {
        DaiConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// This connects to a DAI protocol server.
    pub fn r#connect(
        &self,
        mut dai_protocol: fdomain_client::fidl::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error> {
        DaiConnectorProxyInterface::r#connect(self, dai_protocol)
    }
}

impl DaiConnectorProxyInterface for DaiConnectorProxy {
    fn r#connect(
        &self,
        mut dai_protocol: fdomain_client::fidl::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DaiConnectorConnectRequest>(
            (dai_protocol,),
            0x4e4db05c2eca1450,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for DaiConnectorRequestStream {
    type Protocol = DaiConnectorMarker;
    type ControlHandle = DaiConnectorControlHandle;

    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 {
        DaiConnectorControlHandle { 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 DaiConnectorRequestStream {
    type Item = Result<DaiConnectorRequest, 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 DaiConnectorRequestStream 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 {
                    0x4e4db05c2eca1450 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DaiConnectorConnectRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DaiConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DaiConnectorControlHandle { inner: this.inner.clone() };
                        Ok(DaiConnectorRequest::Connect {
                            dai_protocol: req.dai_protocol,

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

/// For an overview of the DAI protocols see
/// [Digital Audio Interface](//docs/development/audio/drivers/dai.md)
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one DAI and one Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum DaiConnectorRequest {
    /// This connects to a DAI protocol server.
    Connect {
        dai_protocol: fdomain_client::fidl::ServerEnd<DaiMarker>,
        control_handle: DaiConnectorControlHandle,
    },
}

impl DaiConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<DaiMarker>, DaiConnectorControlHandle)> {
        if let DaiConnectorRequest::Connect { dai_protocol, control_handle } = self {
            Some((dai_protocol, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl DaiConnectorControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for HealthMarker {
    type Proxy = HealthProxy;
    type RequestStream = HealthRequestStream;

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

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

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

impl fdomain_client::fidl::Proxy for HealthProxy {
    type Protocol = HealthMarker;

    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 HealthProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Health.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <HealthMarker 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) -> HealthEventStream {
        HealthEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    pub fn r#get_health_state(
        &self,
    ) -> fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>
    {
        HealthProxyInterface::r#get_health_state(self)
    }
}

impl HealthProxyInterface for HealthProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e146d6bca733a84,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HealthState>(
            (),
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for HealthRequestStream {
    type Protocol = HealthMarker;
    type ControlHandle = HealthControlHandle;

    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 {
        HealthControlHandle { 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 HealthRequestStream {
    type Item = Result<HealthRequest, 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 HealthRequestStream 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 {
                    0x4e146d6bca733a84 => {
                        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 = HealthControlHandle { inner: this.inner.clone() };
                        Ok(HealthRequest::GetHealthState {
                            responder: HealthGetHealthStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <HealthMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum HealthRequest {
    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    GetHealthState { responder: HealthGetHealthStateResponder },
}

impl HealthRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_health_state(self) -> Option<(HealthGetHealthStateResponder)> {
        if let HealthRequest::GetHealthState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl HealthControlHandle {}

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

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

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

    fn send_raw(&self, mut state: &HealthState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HealthGetHealthStateResponse>(
            (state,),
            self.tx_id,
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for PacketStreamControlMarker {
    type Proxy = PacketStreamControlProxy;
    type RequestStream = PacketStreamControlRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) PacketStreamControl";
}
pub type PacketStreamControlAllocateVmosResult = Result<Vec<VmoInfo>, i32>;
pub type PacketStreamControlDeallocateVmosResult = Result<(), i32>;
pub type PacketStreamControlRegisterVmosResult = Result<(), i32>;
pub type PacketStreamControlUnregisterVmosResult = Result<(), i32>;
pub type PacketStreamControlGetPacketStreamSinkResult =
    Result<PacketStreamControlGetPacketStreamSinkResponse, i32>;
pub type PacketStreamControlSetPacketStreamSinkResult = Result<(), i32>;
pub type PacketStreamControlStartResult = Result<(), i32>;
pub type PacketStreamControlStopResult = Result<(), i32>;

pub trait PacketStreamControlProxyInterface: Send + Sync {
    type GetPropertiesResponseFut: std::future::Future<Output = Result<PacketStreamProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type AllocateVmosResponseFut: std::future::Future<Output = Result<PacketStreamControlAllocateVmosResult, fidl::Error>>
        + Send;
    fn r#allocate_vmos(&self, payload: &AllocateVmosConfig) -> Self::AllocateVmosResponseFut;
    type DeallocateVmosResponseFut: std::future::Future<Output = Result<PacketStreamControlDeallocateVmosResult, fidl::Error>>
        + Send;
    fn r#deallocate_vmos(&self) -> Self::DeallocateVmosResponseFut;
    type RegisterVmosResponseFut: std::future::Future<Output = Result<PacketStreamControlRegisterVmosResult, fidl::Error>>
        + Send;
    fn r#register_vmos(&self, payload: RegisterVmosConfig) -> Self::RegisterVmosResponseFut;
    type UnregisterVmosResponseFut: std::future::Future<Output = Result<PacketStreamControlUnregisterVmosResult, fidl::Error>>
        + Send;
    fn r#unregister_vmos(&self) -> Self::UnregisterVmosResponseFut;
    type GetPacketStreamSinkResponseFut: std::future::Future<
            Output = Result<PacketStreamControlGetPacketStreamSinkResult, fidl::Error>,
        > + Send;
    fn r#get_packet_stream_sink(&self) -> Self::GetPacketStreamSinkResponseFut;
    type SetPacketStreamSinkResponseFut: std::future::Future<
            Output = Result<PacketStreamControlSetPacketStreamSinkResult, fidl::Error>,
        > + Send;
    fn r#set_packet_stream_sink(
        &self,
        payload: PacketStreamControlSetPacketStreamSinkRequest,
    ) -> Self::SetPacketStreamSinkResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<PacketStreamControlStartResult, fidl::Error>>
        + Send;
    fn r#start(&self) -> Self::StartResponseFut;
    type StopResponseFut: std::future::Future<Output = Result<PacketStreamControlStopResult, fidl::Error>>
        + Send;
    fn r#stop(&self) -> Self::StopResponseFut;
}

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

impl fdomain_client::fidl::Proxy for PacketStreamControlProxy {
    type Protocol = PacketStreamControlMarker;

    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 PacketStreamControlProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/PacketStreamControl.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <PacketStreamControlMarker 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) -> PacketStreamControlEventStream {
        PacketStreamControlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Accessor for top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#get_properties(self)
    }

    /// Request the driver to allocate VMOs for data transfer.
    /// Returns the allocated VMOs and their assigned IDs.
    ///
    /// The returned VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the packet stream is an output stream, then the handle must also include
    /// ZX_RIGHT_WRITE.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `min_vmo_size` is zero or `vmo_count` is zero.
    /// Returns `ZX_ERR_NO_MEMORY` if the driver cannot allocate the requested VMOs.
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are already allocated or registered, or if the
    /// stream is already started. Call `DeallocateVmos` or `UnregisterVmos` first to
    /// reconfigure.
    pub fn r#allocate_vmos(
        &self,
        mut payload: &AllocateVmosConfig,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlAllocateVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#allocate_vmos(self, payload)
    }

    /// Releases all VMOs previously allocated via `AllocateVmos`.
    /// This also occurs automatically when the `PacketStreamControl` channel is closed.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are not currently allocated, or if the stream is
    /// not stopped.
    pub fn r#deallocate_vmos(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlDeallocateVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#deallocate_vmos(self)
    }

    /// Registers client-allocated VMOs with the driver.
    ///
    /// The registered VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the packet stream is an input stream, then the handle must also include
    /// ZX_RIGHT_WRITE.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `vmo_infos` is empty, or if any VMO handle is invalid,
    /// or if duplicate `vmo_id`s are found.
    /// Returns `ZX_ERR_ACCESS_DENIED` if any VMO does not have the required rights.
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are already registered or allocated, or if the
    /// stream is already started. Call `UnregisterVmos` or `DeallocateVmos` first to
    /// reconfigure.
    pub fn r#register_vmos(
        &self,
        mut payload: RegisterVmosConfig,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlRegisterVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#register_vmos(self, payload)
    }

    /// Unregisters all VMOs previously registered via `RegisterVmos`.
    /// This also occurs automatically when the `PacketStreamControl` channel is closed.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are not currently registered, or if the stream is
    /// not stopped.
    pub fn r#unregister_vmos(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlUnregisterVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#unregister_vmos(self)
    }

    /// Connects to the data sink implemented by the driver.
    /// This is used for audio **Output** where the driver consumes data.
    ///
    /// Flow:
    /// 1. App writes audio data to a registered VMO.
    /// 2. App flushes the cache for the written region (if `needs_cache_flush_or_invalidate` is
    ///    true).
    /// 3. App calls `PacketStreamSink.PutPacket` with the location of the data.
    /// 4. Driver consumes the data.
    ///
    /// If this method is called multiple times, the previous `PacketStreamSink` channel is closed,
    /// and any pending requests on that channel are discarded. The new channel replaces the old
    /// one.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the stream is an input stream, or if the driver does
    /// not support this method.
    pub fn r#get_packet_stream_sink(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlGetPacketStreamSinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#get_packet_stream_sink(self)
    }

    /// Provides a data sink to the driver.
    /// This is used for audio **Input** where the driver produces data.
    ///
    /// Flow:
    /// 1. Driver writes audio data to a registered VMO.
    /// 2. Driver calls `PacketStreamSink.PutPacket` with the location of the data.
    /// 3. App receives `PutPacket`.
    /// 4. App invalidates the cache for the region (if `needs_cache_flush_or_invalidate` is
    ///    true).
    /// 5. App reads the data.
    ///
    /// If this method is called multiple times, the driver closes the previous `PacketStreamSink`
    /// channel. The new channel replaces the old one.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the stream is an output stream, or if the driver does
    /// not support this method.
    pub fn r#set_packet_stream_sink(
        &self,
        mut payload: PacketStreamControlSetPacketStreamSinkRequest,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlSetPacketStreamSinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#set_packet_stream_sink(self, payload)
    }

    /// Start the packet-stream.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if:
    /// * Buffers have not been allocated (if `DRIVER_OWNED` was specified)
    ///   and/or registered (if `CLIENT_OWNED` was specified). This is not applicable if
    ///   `INLINE` is supported.
    /// * The stream is already started.
    pub fn r#start(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlStartResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#start(self)
    }

    /// Stop the packet-stream.
    ///
    /// Once the response is received, the stream is halted.
    ///
    /// Behavior depends on the stream direction:
    /// * **Output**: The driver stops consuming packets. Any pending `PacketStreamSink.PutPacket`
    ///   requests will remain pending until `Start` is called again. Clients may call
    ///   `PacketStreamSink.FlushPackets` after `Stop` to discard these pending packets.
    /// * **Input**: The driver stops producing packets. No further `PacketStreamSink.PutPacket`
    ///   calls will be made by the driver until `Start` is called again.
    ///
    /// Note that since `PacketStreamSink` uses a separate channel, there is no strict ordering
    /// guarantee between `Stop` and `PacketStreamSink.PutPacket`:
    /// * For **Output**, some in-flight `PacketStreamSink.PutPacket` calls may
    ///   complete successfully after `Stop` has returned.
    /// * For **Input**, some in-flight `PacketStreamSink.PutPacket` calls may
    ///   arrive at the client after `Stop` has returned.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if the stream is not started.
    pub fn r#stop(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamControlStopResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamControlProxyInterface::r#stop(self)
    }
}

impl PacketStreamControlProxyInterface for PacketStreamControlProxy {
    type GetPropertiesResponseFut = fidl::client::QueryResponseFut<
        PacketStreamProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<PacketStreamControlGetPropertiesResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x586cf4f0f8d2771f,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("get_properties")?;
            Ok(_response.properties)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, PacketStreamProperties>(
            (),
            0x586cf4f0f8d2771f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type AllocateVmosResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlAllocateVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#allocate_vmos(&self, mut payload: &AllocateVmosConfig) -> Self::AllocateVmosResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlAllocateVmosResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<PacketStreamControlAllocateVmosResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7ff1473165ed344b,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("allocate_vmos")?;
            Ok(_response.map(|x| x.vmos))
        }
        self.client
            .send_query_and_decode::<AllocateVmosConfig, PacketStreamControlAllocateVmosResult>(
                payload,
                0x7ff1473165ed344b,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type DeallocateVmosResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlDeallocateVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deallocate_vmos(&self) -> Self::DeallocateVmosResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlDeallocateVmosResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4db5cc85a7b8405b,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("deallocate_vmos")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            PacketStreamControlDeallocateVmosResult,
        >(
            (),
            0x4db5cc85a7b8405b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type RegisterVmosResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlRegisterVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#register_vmos(&self, mut payload: RegisterVmosConfig) -> Self::RegisterVmosResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlRegisterVmosResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x29c3b656a1020bfd,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("register_vmos")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RegisterVmosConfig, PacketStreamControlRegisterVmosResult>(
                &mut payload,
                0x29c3b656a1020bfd,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type UnregisterVmosResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlUnregisterVmosResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#unregister_vmos(&self) -> Self::UnregisterVmosResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlUnregisterVmosResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3e3b4dbfe26b6094,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("unregister_vmos")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            PacketStreamControlUnregisterVmosResult,
        >(
            (),
            0x3e3b4dbfe26b6094,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetPacketStreamSinkResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlGetPacketStreamSinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_packet_stream_sink(&self) -> Self::GetPacketStreamSinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlGetPacketStreamSinkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    PacketStreamControlGetPacketStreamSinkResponse,
                    i32,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7394726463ebbc6a,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("get_packet_stream_sink")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            PacketStreamControlGetPacketStreamSinkResult,
        >(
            (),
            0x7394726463ebbc6a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetPacketStreamSinkResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlSetPacketStreamSinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_packet_stream_sink(
        &self,
        mut payload: PacketStreamControlSetPacketStreamSinkRequest,
    ) -> Self::SetPacketStreamSinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlSetPacketStreamSinkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xab88800e31dc0e4,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("set_packet_stream_sink")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PacketStreamControlSetPacketStreamSinkRequest,
            PacketStreamControlSetPacketStreamSinkResult,
        >(
            &mut payload,
            0xab88800e31dc0e4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type StartResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlStartResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#start(&self) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a584b94d8a6bfd0,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("start")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, PacketStreamControlStartResult>(
                (),
                0x3a584b94d8a6bfd0,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type StopResponseFut = fidl::client::QueryResponseFut<
        PacketStreamControlStopResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#stop(&self) -> Self::StopResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamControlStopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x703e4fafcdd7ef32,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamControlMarker>("stop")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, PacketStreamControlStopResult>(
                (),
                0x703e4fafcdd7ef32,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for PacketStreamControlRequestStream {
    type Protocol = PacketStreamControlMarker;
    type ControlHandle = PacketStreamControlControlHandle;

    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 {
        PacketStreamControlControlHandle { 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 PacketStreamControlRequestStream {
    type Item = Result<PacketStreamControlRequest, 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 PacketStreamControlRequestStream 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 {
                0x586cf4f0f8d2771f => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::GetProperties {
                        responder: PacketStreamControlGetPropertiesResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7ff1473165ed344b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AllocateVmosConfig, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocateVmosConfig>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::AllocateVmos {payload: req,
                        responder: PacketStreamControlAllocateVmosResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4db5cc85a7b8405b => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::DeallocateVmos {
                        responder: PacketStreamControlDeallocateVmosResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x29c3b656a1020bfd => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RegisterVmosConfig, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RegisterVmosConfig>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::RegisterVmos {payload: req,
                        responder: PacketStreamControlRegisterVmosResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3e3b4dbfe26b6094 => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::UnregisterVmos {
                        responder: PacketStreamControlUnregisterVmosResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7394726463ebbc6a => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::GetPacketStreamSink {
                        responder: PacketStreamControlGetPacketStreamSinkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xab88800e31dc0e4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PacketStreamControlSetPacketStreamSinkRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PacketStreamControlSetPacketStreamSinkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::SetPacketStreamSink {payload: req,
                        responder: PacketStreamControlSetPacketStreamSinkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3a584b94d8a6bfd0 => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::Start {
                        responder: PacketStreamControlStartResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x703e4fafcdd7ef32 => {
                    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 = PacketStreamControlControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamControlRequest::Stop {
                        responder: PacketStreamControlStopResponder {
                            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(PacketStreamControlRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PacketStreamControlControlHandle { 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(PacketStreamControlRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PacketStreamControlControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <PacketStreamControlMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Control protocol for establishing and managing the packet stream.
#[derive(Debug)]
pub enum PacketStreamControlRequest {
    /// Accessor for top level static properties.
    GetProperties { responder: PacketStreamControlGetPropertiesResponder },
    /// Request the driver to allocate VMOs for data transfer.
    /// Returns the allocated VMOs and their assigned IDs.
    ///
    /// The returned VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the packet stream is an output stream, then the handle must also include
    /// ZX_RIGHT_WRITE.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `min_vmo_size` is zero or `vmo_count` is zero.
    /// Returns `ZX_ERR_NO_MEMORY` if the driver cannot allocate the requested VMOs.
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are already allocated or registered, or if the
    /// stream is already started. Call `DeallocateVmos` or `UnregisterVmos` first to
    /// reconfigure.
    AllocateVmos {
        payload: AllocateVmosConfig,
        responder: PacketStreamControlAllocateVmosResponder,
    },
    /// Releases all VMOs previously allocated via `AllocateVmos`.
    /// This also occurs automatically when the `PacketStreamControl` channel is closed.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are not currently allocated, or if the stream is
    /// not stopped.
    DeallocateVmos { responder: PacketStreamControlDeallocateVmosResponder },
    /// Registers client-allocated VMOs with the driver.
    ///
    /// The registered VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the packet stream is an input stream, then the handle must also include
    /// ZX_RIGHT_WRITE.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `vmo_infos` is empty, or if any VMO handle is invalid,
    /// or if duplicate `vmo_id`s are found.
    /// Returns `ZX_ERR_ACCESS_DENIED` if any VMO does not have the required rights.
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are already registered or allocated, or if the
    /// stream is already started. Call `UnregisterVmos` or `DeallocateVmos` first to
    /// reconfigure.
    RegisterVmos {
        payload: RegisterVmosConfig,
        responder: PacketStreamControlRegisterVmosResponder,
    },
    /// Unregisters all VMOs previously registered via `RegisterVmos`.
    /// This also occurs automatically when the `PacketStreamControl` channel is closed.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if VMOs are not currently registered, or if the stream is
    /// not stopped.
    UnregisterVmos { responder: PacketStreamControlUnregisterVmosResponder },
    /// Connects to the data sink implemented by the driver.
    /// This is used for audio **Output** where the driver consumes data.
    ///
    /// Flow:
    /// 1. App writes audio data to a registered VMO.
    /// 2. App flushes the cache for the written region (if `needs_cache_flush_or_invalidate` is
    ///    true).
    /// 3. App calls `PacketStreamSink.PutPacket` with the location of the data.
    /// 4. Driver consumes the data.
    ///
    /// If this method is called multiple times, the previous `PacketStreamSink` channel is closed,
    /// and any pending requests on that channel are discarded. The new channel replaces the old
    /// one.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the stream is an input stream, or if the driver does
    /// not support this method.
    GetPacketStreamSink { responder: PacketStreamControlGetPacketStreamSinkResponder },
    /// Provides a data sink to the driver.
    /// This is used for audio **Input** where the driver produces data.
    ///
    /// Flow:
    /// 1. Driver writes audio data to a registered VMO.
    /// 2. Driver calls `PacketStreamSink.PutPacket` with the location of the data.
    /// 3. App receives `PutPacket`.
    /// 4. App invalidates the cache for the region (if `needs_cache_flush_or_invalidate` is
    ///    true).
    /// 5. App reads the data.
    ///
    /// If this method is called multiple times, the driver closes the previous `PacketStreamSink`
    /// channel. The new channel replaces the old one.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the stream is an output stream, or if the driver does
    /// not support this method.
    SetPacketStreamSink {
        payload: PacketStreamControlSetPacketStreamSinkRequest,
        responder: PacketStreamControlSetPacketStreamSinkResponder,
    },
    /// Start the packet-stream.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if:
    /// * Buffers have not been allocated (if `DRIVER_OWNED` was specified)
    ///   and/or registered (if `CLIENT_OWNED` was specified). This is not applicable if
    ///   `INLINE` is supported.
    /// * The stream is already started.
    Start { responder: PacketStreamControlStartResponder },
    /// Stop the packet-stream.
    ///
    /// Once the response is received, the stream is halted.
    ///
    /// Behavior depends on the stream direction:
    /// * **Output**: The driver stops consuming packets. Any pending `PacketStreamSink.PutPacket`
    ///   requests will remain pending until `Start` is called again. Clients may call
    ///   `PacketStreamSink.FlushPackets` after `Stop` to discard these pending packets.
    /// * **Input**: The driver stops producing packets. No further `PacketStreamSink.PutPacket`
    ///   calls will be made by the driver until `Start` is called again.
    ///
    /// Note that since `PacketStreamSink` uses a separate channel, there is no strict ordering
    /// guarantee between `Stop` and `PacketStreamSink.PutPacket`:
    /// * For **Output**, some in-flight `PacketStreamSink.PutPacket` calls may
    ///   complete successfully after `Stop` has returned.
    /// * For **Input**, some in-flight `PacketStreamSink.PutPacket` calls may
    ///   arrive at the client after `Stop` has returned.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if the stream is not started.
    Stop { responder: PacketStreamControlStopResponder },
    /// 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: PacketStreamControlControlHandle,
        method_type: fidl::MethodType,
    },
}

impl PacketStreamControlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(PacketStreamControlGetPropertiesResponder)> {
        if let PacketStreamControlRequest::GetProperties { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_allocate_vmos(
        self,
    ) -> Option<(AllocateVmosConfig, PacketStreamControlAllocateVmosResponder)> {
        if let PacketStreamControlRequest::AllocateVmos { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deallocate_vmos(self) -> Option<(PacketStreamControlDeallocateVmosResponder)> {
        if let PacketStreamControlRequest::DeallocateVmos { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_vmos(
        self,
    ) -> Option<(RegisterVmosConfig, PacketStreamControlRegisterVmosResponder)> {
        if let PacketStreamControlRequest::RegisterVmos { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_vmos(self) -> Option<(PacketStreamControlUnregisterVmosResponder)> {
        if let PacketStreamControlRequest::UnregisterVmos { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_packet_stream_sink(
        self,
    ) -> Option<(PacketStreamControlGetPacketStreamSinkResponder)> {
        if let PacketStreamControlRequest::GetPacketStreamSink { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_packet_stream_sink(
        self,
    ) -> Option<(
        PacketStreamControlSetPacketStreamSinkRequest,
        PacketStreamControlSetPacketStreamSinkResponder,
    )> {
        if let PacketStreamControlRequest::SetPacketStreamSink { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(PacketStreamControlStartResponder)> {
        if let PacketStreamControlRequest::Start { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PacketStreamControlRequest::GetProperties { .. } => "get_properties",
            PacketStreamControlRequest::AllocateVmos { .. } => "allocate_vmos",
            PacketStreamControlRequest::DeallocateVmos { .. } => "deallocate_vmos",
            PacketStreamControlRequest::RegisterVmos { .. } => "register_vmos",
            PacketStreamControlRequest::UnregisterVmos { .. } => "unregister_vmos",
            PacketStreamControlRequest::GetPacketStreamSink { .. } => "get_packet_stream_sink",
            PacketStreamControlRequest::SetPacketStreamSink { .. } => "set_packet_stream_sink",
            PacketStreamControlRequest::Start { .. } => "start",
            PacketStreamControlRequest::Stop { .. } => "stop",
            PacketStreamControlRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            PacketStreamControlRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

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

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

impl PacketStreamControlControlHandle {}

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

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

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

    fn send_raw(&self, mut properties: &PacketStreamProperties) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            PacketStreamControlGetPropertiesResponse,
        >>(
            fidl::encoding::Flexible::new((properties,)),
            self.tx_id,
            0x586cf4f0f8d2771f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<Vec<VmoInfo>, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            PacketStreamControlAllocateVmosResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.as_mut().map_err(|e| *e).map(|vmos| (vmos.as_mut_slice(),)),
            ),
            self.tx_id,
            0x7ff1473165ed344b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<PacketStreamControlGetPacketStreamSinkResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            PacketStreamControlGetPacketStreamSinkResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x7394726463ebbc6a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for PacketStreamSinkMarker {
    type Proxy = PacketStreamSinkProxy;
    type RequestStream = PacketStreamSinkRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) PacketStreamSink";
}
pub type PacketStreamSinkPutPacketResult = Result<PacketStreamSinkPutPacketResponse, i32>;
pub type PacketStreamSinkFlushPacketsResult = Result<(), i32>;

pub trait PacketStreamSinkProxyInterface: Send + Sync {
    type PutPacketResponseFut: std::future::Future<Output = Result<PacketStreamSinkPutPacketResult, fidl::Error>>
        + Send;
    fn r#put_packet(&self, payload: PacketStreamSinkPutPacketRequest)
    -> Self::PutPacketResponseFut;
    type FlushPacketsResponseFut: std::future::Future<Output = Result<PacketStreamSinkFlushPacketsResult, fidl::Error>>
        + Send;
    fn r#flush_packets(&self) -> Self::FlushPacketsResponseFut;
}

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

impl fdomain_client::fidl::Proxy for PacketStreamSinkProxy {
    type Protocol = PacketStreamSinkMarker;

    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 PacketStreamSinkProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/PacketStreamSink.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <PacketStreamSinkMarker 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) -> PacketStreamSinkEventStream {
        PacketStreamSinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Submits a packet to be processed by the server.
    ///
    /// The client may queue multiple packets by calling `PutPacket` repeatedly.
    /// Packets are processed in the order they were submitted. This call
    /// blocks until the payload is processed. When this call returns, the
    /// buffer region is guaranteed to be available for reuse.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if the stream is not started or configured.
    /// Returns `ZX_ERR_CANCELED` if `FlushPackets` was called.
    /// Returns `ZX_ERR_INVALID_ARGS` if the packet is invalid. This includes:
    /// * The payload is missing.
    /// * `inline_data` is used but `supported_buffer_types` does not include `INLINE`.
    /// * `vmo_transfer` is used but `supported_buffer_types` does not include `CLIENT_OWNED` or
    ///   `DRIVER_OWNED`.
    /// * `vmo_id` is unrecognized, or `vmo_offset` + `payload_size` exceeds the VMO size.
    ///
    /// Note: The server is not required to detect if a VMO region is currently in use by a
    /// previous pending packet. Clients are responsible for managing buffer usage.
    pub fn r#put_packet(
        &self,
        mut payload: PacketStreamSinkPutPacketRequest,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamSinkPutPacketResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamSinkProxyInterface::r#put_packet(self, payload)
    }

    /// Flushes all packets currently pending without processing them.
    /// This call waits until all pending packets are completed or canceled.
    ///
    /// Note: A packet may be partially processed (e.g. if it contains multiple
    /// audio frames, or if the data does not align with encoded frame boundaries)
    /// before it is canceled.
    pub fn r#flush_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PacketStreamSinkFlushPacketsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        PacketStreamSinkProxyInterface::r#flush_packets(self)
    }
}

impl PacketStreamSinkProxyInterface for PacketStreamSinkProxy {
    type PutPacketResponseFut = fidl::client::QueryResponseFut<
        PacketStreamSinkPutPacketResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#put_packet(
        &self,
        mut payload: PacketStreamSinkPutPacketRequest,
    ) -> Self::PutPacketResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamSinkPutPacketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<PacketStreamSinkPutPacketResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x25a8e35efba81f2b,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamSinkMarker>("put_packet")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PacketStreamSinkPutPacketRequest,
            PacketStreamSinkPutPacketResult,
        >(
            &mut payload,
            0x25a8e35efba81f2b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlushPacketsResponseFut = fidl::client::QueryResponseFut<
        PacketStreamSinkFlushPacketsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#flush_packets(&self) -> Self::FlushPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PacketStreamSinkFlushPacketsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x13f16ca37ede8a4,
            >(_buf?)?
            .into_result_fdomain::<PacketStreamSinkMarker>("flush_packets")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            PacketStreamSinkFlushPacketsResult,
        >(
            (),
            0x13f16ca37ede8a4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for PacketStreamSinkRequestStream {
    type Protocol = PacketStreamSinkMarker;
    type ControlHandle = PacketStreamSinkControlHandle;

    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 {
        PacketStreamSinkControlHandle { 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 PacketStreamSinkRequestStream {
    type Item = Result<PacketStreamSinkRequest, 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 PacketStreamSinkRequestStream 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 {
                0x25a8e35efba81f2b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PacketStreamSinkPutPacketRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<PacketStreamSinkPutPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PacketStreamSinkControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamSinkRequest::PutPacket {payload: req,
                        responder: PacketStreamSinkPutPacketResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x13f16ca37ede8a4 => {
                    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 = PacketStreamSinkControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PacketStreamSinkRequest::FlushPackets {
                        responder: PacketStreamSinkFlushPacketsResponder {
                            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(PacketStreamSinkRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PacketStreamSinkControlHandle { 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(PacketStreamSinkRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PacketStreamSinkControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <PacketStreamSinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// The protocol for streaming packet-based audio data.
/// This protocol functions as a data sink. The "server" of this protocol consumes packets,
/// and the "client" produces packets.
///
/// This protocol can be used in two directions:
/// 1. **Output (Client -> Driver)**: The Driver implements `PacketStreamSink`. The Client (App)
///    calls `PutPacket`.
/// 2. **Input (Driver -> Client)**: The Client (App) implements `PacketStreamSink`. The Driver
///    calls `PutPacket`.
#[derive(Debug)]
pub enum PacketStreamSinkRequest {
    /// Submits a packet to be processed by the server.
    ///
    /// The client may queue multiple packets by calling `PutPacket` repeatedly.
    /// Packets are processed in the order they were submitted. This call
    /// blocks until the payload is processed. When this call returns, the
    /// buffer region is guaranteed to be available for reuse.
    ///
    /// Returns `ZX_ERR_BAD_STATE` if the stream is not started or configured.
    /// Returns `ZX_ERR_CANCELED` if `FlushPackets` was called.
    /// Returns `ZX_ERR_INVALID_ARGS` if the packet is invalid. This includes:
    /// * The payload is missing.
    /// * `inline_data` is used but `supported_buffer_types` does not include `INLINE`.
    /// * `vmo_transfer` is used but `supported_buffer_types` does not include `CLIENT_OWNED` or
    ///   `DRIVER_OWNED`.
    /// * `vmo_id` is unrecognized, or `vmo_offset` + `payload_size` exceeds the VMO size.
    ///
    /// Note: The server is not required to detect if a VMO region is currently in use by a
    /// previous pending packet. Clients are responsible for managing buffer usage.
    PutPacket {
        payload: PacketStreamSinkPutPacketRequest,
        responder: PacketStreamSinkPutPacketResponder,
    },
    /// Flushes all packets currently pending without processing them.
    /// This call waits until all pending packets are completed or canceled.
    ///
    /// Note: A packet may be partially processed (e.g. if it contains multiple
    /// audio frames, or if the data does not align with encoded frame boundaries)
    /// before it is canceled.
    FlushPackets { responder: PacketStreamSinkFlushPacketsResponder },
    /// 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: PacketStreamSinkControlHandle,
        method_type: fidl::MethodType,
    },
}

impl PacketStreamSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_put_packet(
        self,
    ) -> Option<(PacketStreamSinkPutPacketRequest, PacketStreamSinkPutPacketResponder)> {
        if let PacketStreamSinkRequest::PutPacket { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush_packets(self) -> Option<(PacketStreamSinkFlushPacketsResponder)> {
        if let PacketStreamSinkRequest::FlushPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl PacketStreamSinkControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RingBufferMarker {
    type Proxy = RingBufferProxy;
    type RequestStream = RingBufferRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RingBuffer";
}
pub type RingBufferGetVmoResult = Result<(u32, fdomain_client::Vmo), GetVmoError>;
pub type RingBufferSetActiveChannelsResult = Result<i64, i32>;

pub trait RingBufferProxyInterface: Send + Sync {
    type GetPropertiesResponseFut: std::future::Future<Output = Result<RingBufferProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type WatchClockRecoveryPositionInfoResponseFut: std::future::Future<Output = Result<RingBufferPositionInfo, fidl::Error>>
        + Send;
    fn r#watch_clock_recovery_position_info(
        &self,
    ) -> Self::WatchClockRecoveryPositionInfoResponseFut;
    type GetVmoResponseFut: std::future::Future<Output = Result<RingBufferGetVmoResult, fidl::Error>>
        + Send;
    fn r#get_vmo(
        &self,
        min_frames: u32,
        clock_recovery_notifications_per_ring: u32,
    ) -> Self::GetVmoResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<i64, fidl::Error>> + Send;
    fn r#start(&self) -> Self::StartResponseFut;
    type StopResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#stop(&self) -> Self::StopResponseFut;
    type SetActiveChannelsResponseFut: std::future::Future<Output = Result<RingBufferSetActiveChannelsResult, fidl::Error>>
        + Send;
    fn r#set_active_channels(
        &self,
        active_channels_bitmask: u64,
    ) -> Self::SetActiveChannelsResponseFut;
    type WatchDelayInfoResponseFut: std::future::Future<Output = Result<DelayInfo, fidl::Error>>
        + Send;
    fn r#watch_delay_info(&self) -> Self::WatchDelayInfoResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RingBufferProxy {
    type Protocol = RingBufferMarker;

    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 RingBufferProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/RingBuffer.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RingBufferMarker 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) -> RingBufferEventStream {
        RingBufferEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Accessor for top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        RingBufferProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RingBufferProxyInterface::r#get_properties(self)
    }

    /// Gets the ring buffer current position via a hanging get.
    ///
    /// `WatchClockRecoveryPositionInfo` may only be called after `GetVmo` was called, where a
    /// `clock_recovery_notifications_per_ring` was specified.
    ///
    /// The driver must respond to a client's first `WatchClockRecoveryPositionInfo` call, but will
    /// not respond to subsequent client calls until the position information has changed from what
    /// was most recently provided to that client.
    ///
    /// The driver must not respond to a `WatchClockRecoveryPositionInfo` until after it has replied
    /// to the `Start` command.
    ///
    /// At the `start_time` returned by `Start`, position is always 0. From there, it
    /// progresses at the rate specified by the rate, sample format (and clock domain,
    /// if the device is not in the same clock domain as`CLOCK_MONOTONIC`).
    ///
    /// If `clock_recovery_notifications_per_ring` is not zero, the driver will reply with its
    /// estimated position to be used for clock recovery at most at
    /// `clock_recovery_notifications_per_ring` frequency.
    ///
    /// The `RingBufferPositionInfo` return values must include timestamps that are monotonically
    /// increasing.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if there is
    /// already a pending `WatchClockRecoveryPositionInfo` for this client.
    pub fn r#watch_clock_recovery_position_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        RingBufferPositionInfo,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RingBufferProxyInterface::r#watch_clock_recovery_position_info(self)
    }

    /// Requests a shared buffer to be used for moving bulk audio data between client and driver.
    ///
    /// The client requests `min_frames` as the size for part of the ring buffer it needs.
    /// The driver returns the actual size of allocated ring buffer space in `num_frames`.
    ///
    /// `num_frames` must be at least `min_frames` plus `driver_transfer_bytes` (in frames) such
    /// that ring buffer contents can be transfered in and out, or else the call must be failed
    /// with GetVmoError.INVALID_ARGS.
    ///
    /// The driver may increase the ring buffer size beyond `min_frames` plus
    /// `driver_transfer_bytes` (in frames) due to any internal requirements, for instance
    /// alignment.
    ///
    /// Clients can treat the entire returned ring buffer as safe to access, except for the
    /// `driver_transfer_bytes` immediately adjacent to the current position, see the
    /// `driver_transfer_bytes` parameter specification in `RingBufferProperties` for more details.
    ///
    /// The returned VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the ring buffer is "outgoing" (conveys audio data from client to device), then the
    /// handle must also include ZX_RIGHT_WRITE.
    ///
    /// If `clock_recovery_notifications_per_ring` is non-zero, the driver will send replies to
    /// `WatchClockRecoveryPositionInfo` client requests at most at
    /// `clock_recovery_notifications_per_ring` frequency. These notifications are meant to be used
    /// for clock recovery.
    pub fn r#get_vmo(
        &self,
        mut min_frames: u32,
        mut clock_recovery_notifications_per_ring: u32,
    ) -> fidl::client::QueryResponseFut<
        RingBufferGetVmoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RingBufferProxyInterface::r#get_vmo(self, min_frames, clock_recovery_notifications_per_ring)
    }

    /// Start the ring buffer.
    ///
    /// The `start_time` value (in the CLOCK_MONOTONIC timeline) indicates when position began
    /// moving, starting at the beginning of the ring buffer, i.e. the driver has started to read or
    /// write from or to the ring buffer position 0, subject to the overall position and buffering
    /// behavior described in 'Ring buffer behavior' below.
    ///
    /// If `Start` is called before `GetVmo`, the channel must be closed with `ZX_ERR_BAD_STATE`.
    /// If `Start` is called while this RingBuffer is already started, or if `Start` is called for
    /// a second time before the first call has completed, then the channel must be closed with an
    /// error `ZX_ERR_BAD_STATE` returned.
    /// If `Start` is called before `SetActiveChannels`, then by default all channels are active.
    pub fn r#start(
        &self,
    ) -> fidl::client::QueryResponseFut<i64, fdomain_client::fidl::FDomainResourceDialect> {
        RingBufferProxyInterface::r#start(self)
    }

    /// Stop the ring buffer.
    ///
    /// Once this call's response is received, no further position notifications will be sent until
    /// `Start` is called again.
    ///
    /// If `Stop` is called before `GetVmo`, the channel must be closed with `ZX_ERR_BAD_STATE`.
    pub fn r#stop(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        RingBufferProxyInterface::r#stop(self)
    }

    /// Sets which channels are active via a bitmask.
    ///
    /// The total number of channels is the `number_of_channels` in `Format`, specifically in
    /// `PcmFormat`, i.e. this bitmask has up to `number_of_channels` bits set (maximum 64).
    /// The least significant bit corresponds to channel index 0. Channels not set (bits are 0) in
    /// the bitmask are inactive. By default all channels are active. Hence creating a RingBuffer
    /// turns on the hardware associated for all channels.
    ///
    /// Inactive channels indicate to the driver that it may turn off hardware associated with the
    /// inactive channels. A subsequent `SetActiveChannels` setting an inactive channel to active
    /// may incur in a `turn_on_delay` to actually restart playback/capture of the channels.
    ///
    /// Deactivating one, several, or all channels does not `Stop` the ring buffer, nor does it
    /// change the ring buffer's behavior with regard to position. Once `Start` is called, a ring
    /// buffer's position advances (and position notifications sent as needed) regardless of the
    /// number of active channels, including if no channels are active. This means that the format
    /// in the ring buffer is not changed.
    ///
    /// If the driver does not support deactivating channels, it must return `ZX_ERR_NOT_SUPPORTED`.
    /// If the mask is incorrect, i.e. enables channels outside the number of bits to use for a
    /// given `number_of_channels`, then the driver must return `ZX_ERR_INVALID_ARGS`.
    ///
    /// The `set_time` value (in the CLOCK_MONOTONIC timeline) indicates when configuring
    /// the hardware to activate or deactivate channels is completed. `set_time` does not include
    /// the potential `turn_on_delay`, the driver does not delay the reply waiting for the
    /// hardware to actually turn on, the driver replies with a `set_time` indicating when the
    /// hardware configuration was completed. If the requested channel configuration is already
    /// active, the returned `set_time` can be before `SetActiveChannels` was called but must be
    /// before the reply is sent. If called again with the same configuration, the reply must
    /// include the same `set_time` value as was previously returned.
    ///
    /// For input channels, it is not required that the driver zero-out inactive channels.
    ///
    /// If `SetActiveChannels` is called for a second time before the first call has completed,
    /// the channel must be closed with an error `ZX_ERR_BAD_STATE` returned.
    pub fn r#set_active_channels(
        &self,
        mut active_channels_bitmask: u64,
    ) -> fidl::client::QueryResponseFut<
        RingBufferSetActiveChannelsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RingBufferProxyInterface::r#set_active_channels(self, active_channels_bitmask)
    }

    /// Get information about delays via a hanging get.
    ///
    /// The driver will immediately reply to the first `WatchDelayInfo` sent by the client.
    /// The driver will not respond to subsequent client `WatchDelayInfo` calls until the delay info
    /// changes from what was most recently reported.
    ///
    /// If `WatchDelayInfo` is called for a second time before the first call has completed, the
    /// channel must be closed with an error `ZX_ERR_BAD_STATE` returned.
    pub fn r#watch_delay_info(
        &self,
    ) -> fidl::client::QueryResponseFut<DelayInfo, fdomain_client::fidl::FDomainResourceDialect>
    {
        RingBufferProxyInterface::r#watch_delay_info(self)
    }
}

impl RingBufferProxyInterface for RingBufferProxy {
    type GetPropertiesResponseFut = fidl::client::QueryResponseFut<
        RingBufferProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RingBufferGetPropertiesResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x12947f061a8fe1,
            >(_buf?)?;
            Ok(_response.properties)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, RingBufferProperties>(
            (),
            0x12947f061a8fe1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        RingBufferGetVmoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_vmo(
        &self,
        mut min_frames: u32,
        mut clock_recovery_notifications_per_ring: u32,
    ) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RingBufferGetVmoResponse, GetVmoError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x44c8f4f5680e853a,
            >(_buf?)?;
            Ok(_response.map(|x| (x.num_frames, x.ring_buffer)))
        }
        self.client.send_query_and_decode::<RingBufferGetVmoRequest, RingBufferGetVmoResult>(
            (min_frames, clock_recovery_notifications_per_ring),
            0x44c8f4f5680e853a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type SetActiveChannelsResponseFut = fidl::client::QueryResponseFut<
        RingBufferSetActiveChannelsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_active_channels(
        &self,
        mut active_channels_bitmask: u64,
    ) -> Self::SetActiveChannelsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferSetActiveChannelsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RingBufferSetActiveChannelsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x605464c1d384f309,
            >(_buf?)?;
            Ok(_response.map(|x| x.set_time))
        }
        self.client.send_query_and_decode::<
            RingBufferSetActiveChannelsRequest,
            RingBufferSetActiveChannelsResult,
        >(
            (active_channels_bitmask,),
            0x605464c1d384f309,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchDelayInfoResponseFut =
        fidl::client::QueryResponseFut<DelayInfo, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#watch_delay_info(&self) -> Self::WatchDelayInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DelayInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<RingBufferWatchDelayInfoResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6c1248db213fcf9f,
            >(_buf?)?
            .into_result_fdomain::<RingBufferMarker>("watch_delay_info")?;
            Ok(_response.delay_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DelayInfo>(
            (),
            0x6c1248db213fcf9f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RingBufferRequestStream {
    type Protocol = RingBufferMarker;
    type ControlHandle = RingBufferControlHandle;

    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 {
        RingBufferControlHandle { 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 RingBufferRequestStream {
    type Item = Result<RingBufferRequest, 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 RingBufferRequestStream 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 {
                    0x12947f061a8fe1 => {
                        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 = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::GetProperties {
                            responder: RingBufferGetPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x694d5b898a4167e5 => {
                        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 = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::WatchClockRecoveryPositionInfo {
                            responder: RingBufferWatchClockRecoveryPositionInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x44c8f4f5680e853a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RingBufferGetVmoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RingBufferGetVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::GetVmo {
                            min_frames: req.min_frames,
                            clock_recovery_notifications_per_ring: req
                                .clock_recovery_notifications_per_ring,

                            responder: RingBufferGetVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5dd780a769a8892d => {
                        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 = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::Start {
                            responder: RingBufferStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49a73d9cf1d4e110 => {
                        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 = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::Stop {
                            responder: RingBufferStopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x605464c1d384f309 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RingBufferSetActiveChannelsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RingBufferSetActiveChannelsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::SetActiveChannels {
                            active_channels_bitmask: req.active_channels_bitmask,

                            responder: RingBufferSetActiveChannelsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c1248db213fcf9f => {
                        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 = RingBufferControlHandle { inner: this.inner.clone() };
                        Ok(RingBufferRequest::WatchDelayInfo {
                            responder: RingBufferWatchDelayInfoResponder {
                                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(RingBufferRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: RingBufferControlHandle { 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(RingBufferRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: RingBufferControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <RingBufferMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Ring buffers are used to convey audio between parties (usually in different processes), allowing
/// concurrent, asynchronous data access without requiring locks. This pattern works because both
/// parties share an understanding of which buffer areas are safe to access, and how those areas
/// change over time.
///
/// For in-depth description of the responsibilities for both _producers_ and _consumers_,
/// before the ring buffer is started as well as while it is active, please see
/// [Ring Buffer Behavior](https://fuchsia.dev/fuchsia-src/development/audio/ring_buffer.md).
#[derive(Debug)]
pub enum RingBufferRequest {
    /// Accessor for top level static properties.
    GetProperties { responder: RingBufferGetPropertiesResponder },
    /// Gets the ring buffer current position via a hanging get.
    ///
    /// `WatchClockRecoveryPositionInfo` may only be called after `GetVmo` was called, where a
    /// `clock_recovery_notifications_per_ring` was specified.
    ///
    /// The driver must respond to a client's first `WatchClockRecoveryPositionInfo` call, but will
    /// not respond to subsequent client calls until the position information has changed from what
    /// was most recently provided to that client.
    ///
    /// The driver must not respond to a `WatchClockRecoveryPositionInfo` until after it has replied
    /// to the `Start` command.
    ///
    /// At the `start_time` returned by `Start`, position is always 0. From there, it
    /// progresses at the rate specified by the rate, sample format (and clock domain,
    /// if the device is not in the same clock domain as`CLOCK_MONOTONIC`).
    ///
    /// If `clock_recovery_notifications_per_ring` is not zero, the driver will reply with its
    /// estimated position to be used for clock recovery at most at
    /// `clock_recovery_notifications_per_ring` frequency.
    ///
    /// The `RingBufferPositionInfo` return values must include timestamps that are monotonically
    /// increasing.
    ///
    /// The driver will close the protocol channel with an error of `ZX_ERR_BAD_STATE`, if there is
    /// already a pending `WatchClockRecoveryPositionInfo` for this client.
    WatchClockRecoveryPositionInfo { responder: RingBufferWatchClockRecoveryPositionInfoResponder },
    /// Requests a shared buffer to be used for moving bulk audio data between client and driver.
    ///
    /// The client requests `min_frames` as the size for part of the ring buffer it needs.
    /// The driver returns the actual size of allocated ring buffer space in `num_frames`.
    ///
    /// `num_frames` must be at least `min_frames` plus `driver_transfer_bytes` (in frames) such
    /// that ring buffer contents can be transfered in and out, or else the call must be failed
    /// with GetVmoError.INVALID_ARGS.
    ///
    /// The driver may increase the ring buffer size beyond `min_frames` plus
    /// `driver_transfer_bytes` (in frames) due to any internal requirements, for instance
    /// alignment.
    ///
    /// Clients can treat the entire returned ring buffer as safe to access, except for the
    /// `driver_transfer_bytes` immediately adjacent to the current position, see the
    /// `driver_transfer_bytes` parameter specification in `RingBufferProperties` for more details.
    ///
    /// The returned VMO handle must include ZX_RIGHT_TRANSFER, ZX_RIGHT_READ and ZX_RIGHT_MAP.
    /// If the ring buffer is "outgoing" (conveys audio data from client to device), then the
    /// handle must also include ZX_RIGHT_WRITE.
    ///
    /// If `clock_recovery_notifications_per_ring` is non-zero, the driver will send replies to
    /// `WatchClockRecoveryPositionInfo` client requests at most at
    /// `clock_recovery_notifications_per_ring` frequency. These notifications are meant to be used
    /// for clock recovery.
    GetVmo {
        min_frames: u32,
        clock_recovery_notifications_per_ring: u32,
        responder: RingBufferGetVmoResponder,
    },
    /// Start the ring buffer.
    ///
    /// The `start_time` value (in the CLOCK_MONOTONIC timeline) indicates when position began
    /// moving, starting at the beginning of the ring buffer, i.e. the driver has started to read or
    /// write from or to the ring buffer position 0, subject to the overall position and buffering
    /// behavior described in 'Ring buffer behavior' below.
    ///
    /// If `Start` is called before `GetVmo`, the channel must be closed with `ZX_ERR_BAD_STATE`.
    /// If `Start` is called while this RingBuffer is already started, or if `Start` is called for
    /// a second time before the first call has completed, then the channel must be closed with an
    /// error `ZX_ERR_BAD_STATE` returned.
    /// If `Start` is called before `SetActiveChannels`, then by default all channels are active.
    Start { responder: RingBufferStartResponder },
    /// Stop the ring buffer.
    ///
    /// Once this call's response is received, no further position notifications will be sent until
    /// `Start` is called again.
    ///
    /// If `Stop` is called before `GetVmo`, the channel must be closed with `ZX_ERR_BAD_STATE`.
    Stop { responder: RingBufferStopResponder },
    /// Sets which channels are active via a bitmask.
    ///
    /// The total number of channels is the `number_of_channels` in `Format`, specifically in
    /// `PcmFormat`, i.e. this bitmask has up to `number_of_channels` bits set (maximum 64).
    /// The least significant bit corresponds to channel index 0. Channels not set (bits are 0) in
    /// the bitmask are inactive. By default all channels are active. Hence creating a RingBuffer
    /// turns on the hardware associated for all channels.
    ///
    /// Inactive channels indicate to the driver that it may turn off hardware associated with the
    /// inactive channels. A subsequent `SetActiveChannels` setting an inactive channel to active
    /// may incur in a `turn_on_delay` to actually restart playback/capture of the channels.
    ///
    /// Deactivating one, several, or all channels does not `Stop` the ring buffer, nor does it
    /// change the ring buffer's behavior with regard to position. Once `Start` is called, a ring
    /// buffer's position advances (and position notifications sent as needed) regardless of the
    /// number of active channels, including if no channels are active. This means that the format
    /// in the ring buffer is not changed.
    ///
    /// If the driver does not support deactivating channels, it must return `ZX_ERR_NOT_SUPPORTED`.
    /// If the mask is incorrect, i.e. enables channels outside the number of bits to use for a
    /// given `number_of_channels`, then the driver must return `ZX_ERR_INVALID_ARGS`.
    ///
    /// The `set_time` value (in the CLOCK_MONOTONIC timeline) indicates when configuring
    /// the hardware to activate or deactivate channels is completed. `set_time` does not include
    /// the potential `turn_on_delay`, the driver does not delay the reply waiting for the
    /// hardware to actually turn on, the driver replies with a `set_time` indicating when the
    /// hardware configuration was completed. If the requested channel configuration is already
    /// active, the returned `set_time` can be before `SetActiveChannels` was called but must be
    /// before the reply is sent. If called again with the same configuration, the reply must
    /// include the same `set_time` value as was previously returned.
    ///
    /// For input channels, it is not required that the driver zero-out inactive channels.
    ///
    /// If `SetActiveChannels` is called for a second time before the first call has completed,
    /// the channel must be closed with an error `ZX_ERR_BAD_STATE` returned.
    SetActiveChannels {
        active_channels_bitmask: u64,
        responder: RingBufferSetActiveChannelsResponder,
    },
    /// Get information about delays via a hanging get.
    ///
    /// The driver will immediately reply to the first `WatchDelayInfo` sent by the client.
    /// The driver will not respond to subsequent client `WatchDelayInfo` calls until the delay info
    /// changes from what was most recently reported.
    ///
    /// If `WatchDelayInfo` is called for a second time before the first call has completed, the
    /// channel must be closed with an error `ZX_ERR_BAD_STATE` returned.
    WatchDelayInfo { responder: RingBufferWatchDelayInfoResponder },
    /// 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: RingBufferControlHandle,
        method_type: fidl::MethodType,
    },
}

impl RingBufferRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(RingBufferGetPropertiesResponder)> {
        if let RingBufferRequest::GetProperties { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_clock_recovery_position_info(
        self,
    ) -> Option<(RingBufferWatchClockRecoveryPositionInfoResponder)> {
        if let RingBufferRequest::WatchClockRecoveryPositionInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo(self) -> Option<(u32, u32, RingBufferGetVmoResponder)> {
        if let RingBufferRequest::GetVmo {
            min_frames,
            clock_recovery_notifications_per_ring,
            responder,
        } = self
        {
            Some((min_frames, clock_recovery_notifications_per_ring, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(RingBufferStartResponder)> {
        if let RingBufferRequest::Start { responder } = self { Some((responder)) } else { None }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_active_channels(self) -> Option<(u64, RingBufferSetActiveChannelsResponder)> {
        if let RingBufferRequest::SetActiveChannels { active_channels_bitmask, responder } = self {
            Some((active_channels_bitmask, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_delay_info(self) -> Option<(RingBufferWatchDelayInfoResponder)> {
        if let RingBufferRequest::WatchDelayInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RingBufferRequest::GetProperties { .. } => "get_properties",
            RingBufferRequest::WatchClockRecoveryPositionInfo { .. } => {
                "watch_clock_recovery_position_info"
            }
            RingBufferRequest::GetVmo { .. } => "get_vmo",
            RingBufferRequest::Start { .. } => "start",
            RingBufferRequest::Stop { .. } => "stop",
            RingBufferRequest::SetActiveChannels { .. } => "set_active_channels",
            RingBufferRequest::WatchDelayInfo { .. } => "watch_delay_info",
            RingBufferRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            RingBufferRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl RingBufferControlHandle {}

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

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

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

    fn send_raw(&self, mut properties: &RingBufferProperties) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RingBufferGetPropertiesResponse>(
            (properties,),
            self.tx_id,
            0x12947f061a8fe1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut position_info: &RingBufferPositionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RingBufferWatchClockRecoveryPositionInfoResponse>(
            (position_info,),
            self.tx_id,
            0x694d5b898a4167e5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(u32, fdomain_client::Vmo), GetVmoError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<RingBufferGetVmoResponse, GetVmoError>>(
                result,
                self.tx_id,
                0x44c8f4f5680e853a,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(&self, mut start_time: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RingBufferStartResponse>(
            (start_time,),
            self.tx_id,
            0x5dd780a769a8892d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<i64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RingBufferSetActiveChannelsResponse,
            i32,
        >>(
            result.map(|set_time| (set_time,)),
            self.tx_id,
            0x605464c1d384f309,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut delay_info: &DelayInfo) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<RingBufferWatchDelayInfoResponse>>(
                fidl::encoding::Flexible::new((delay_info,)),
                self.tx_id,
                0x6c1248db213fcf9f,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for StreamConfigMarker {
    type Proxy = StreamConfigProxy;
    type RequestStream = StreamConfigRequestStream;

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

pub trait StreamConfigProxyInterface: Send + Sync {
    type GetHealthStateResponseFut: std::future::Future<Output = Result<HealthState, fidl::Error>>
        + Send;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut;
    fn r#signal_processing_connect(
        &self,
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type GetPropertiesResponseFut: std::future::Future<Output = Result<StreamProperties, fidl::Error>>
        + Send;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut;
    type GetSupportedFormatsResponseFut: std::future::Future<Output = Result<Vec<SupportedFormats>, fidl::Error>>
        + Send;
    fn r#get_supported_formats(&self) -> Self::GetSupportedFormatsResponseFut;
    fn r#create_ring_buffer(
        &self,
        format: &Format,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error>;
    type WatchGainStateResponseFut: std::future::Future<Output = Result<GainState, fidl::Error>>
        + Send;
    fn r#watch_gain_state(&self) -> Self::WatchGainStateResponseFut;
    fn r#set_gain(&self, target_state: &GainState) -> Result<(), fidl::Error>;
    type WatchPlugStateResponseFut: std::future::Future<Output = Result<PlugState, fidl::Error>>
        + Send;
    fn r#watch_plug_state(&self) -> Self::WatchPlugStateResponseFut;
}

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

impl fdomain_client::fidl::Proxy for StreamConfigProxy {
    type Protocol = StreamConfigMarker;

    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 StreamConfigProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/StreamConfig.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <StreamConfigMarker 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) -> StreamConfigEventStream {
        StreamConfigEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    pub fn r#get_health_state(
        &self,
    ) -> fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>
    {
        StreamConfigProxyInterface::r#get_health_state(self)
    }

    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    pub fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        StreamConfigProxyInterface::r#signal_processing_connect(self, protocol)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamProperties,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StreamConfigProxyInterface::r#get_properties(self)
    }

    /// Gets formats supported by a given driver. When not all combinations supported by the
    /// driver can be described with one `SupportedFormats`, the driver returns more than one
    /// `SupportedFormats` in the returned vector. For example, if one `SupportedFormats` allows
    /// for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
    /// 96KHz, then the driver replies with 2 `SupportedFormats`: <<32bits>,<48KHz>> and
    /// <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
    /// bits per sample. In the case where the driver supports either 16 or 32 bits samples at
    /// either 48 or 96KHz, the driver would reply with 1 `SupportedFormats`:
    /// <<16bits,32bits>,<48KHz,96KHz>>.
    pub fn r#get_supported_formats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<SupportedFormats>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StreamConfigProxyInterface::r#get_supported_formats(self)
    }

    /// `CreateRingBuffer` is sent by clients to select a stream format based on information that
    /// the driver provides in `GetSupportedFormats` what is supported by the client, and any other
    /// requirement. The `ring_buffer` channel is used to control the audio buffer, if a previous
    /// ring buffer channel had been established and was still active, the driver must close that
    /// (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
    /// operations in the process.
    pub fn r#create_ring_buffer(
        &self,
        mut format: &Format,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        StreamConfigProxyInterface::r#create_ring_buffer(self, format, ring_buffer)
    }

    /// Get the gain state via a hanging get. The driver will reply to the first `WatchGainState`
    /// sent by the client and this reply must include a `gain_db` set to 0dB or lower. The driver
    /// will not respond to subsequent client `WatchGainState` calls until the gain state changes
    /// from what was most recently reported.
    /// If `WatchGainState` is called for a second time before the first call has completed, then
    /// the protocol channel must be closed with the error `ZX_ERR_BAD_STATE`.
    pub fn r#watch_gain_state(
        &self,
    ) -> fidl::client::QueryResponseFut<GainState, fdomain_client::fidl::FDomainResourceDialect>
    {
        StreamConfigProxyInterface::r#watch_gain_state(self)
    }

    /// Client update of the gain state.
    pub fn r#set_gain(&self, mut target_state: &GainState) -> Result<(), fidl::Error> {
        StreamConfigProxyInterface::r#set_gain(self, target_state)
    }

    /// Get the plug detect state via a hanging get. The driver will reply to the first
    /// `WatchPlugState` sent by the client. The driver will not respond to subsequent client
    /// `WatchPlugState` calls until the plug state changes from what was most recently reported.
    /// If `WatchPlugState` is called for a second time before the first call has completed, then
    /// the protocol channel must be closed with the error `ZX_ERR_BAD_STATE`.
    pub fn r#watch_plug_state(
        &self,
    ) -> fidl::client::QueryResponseFut<PlugState, fdomain_client::fidl::FDomainResourceDialect>
    {
        StreamConfigProxyInterface::r#watch_plug_state(self)
    }
}

impl StreamConfigProxyInterface for StreamConfigProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e146d6bca733a84,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HealthState>(
            (),
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#signal_processing_connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetSupportedFormatsResponseFut = fidl::client::QueryResponseFut<
        Vec<SupportedFormats>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_supported_formats(&self) -> Self::GetSupportedFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<SupportedFormats>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamConfigGetSupportedFormatsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x448efa7850cafe7e,
            >(_buf?)?;
            Ok(_response.supported_formats)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<SupportedFormats>>(
            (),
            0x448efa7850cafe7e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#create_ring_buffer(
        &self,
        mut format: &Format,
        mut ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigCreateRingBufferRequest>(
            (format, ring_buffer),
            0x2afb19dd13faa1ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#set_gain(&self, mut target_state: &GainState) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigSetGainRequest>(
            (target_state,),
            0x3943b41498c6a384,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for StreamConfigRequestStream {
    type Protocol = StreamConfigMarker;
    type ControlHandle = StreamConfigControlHandle;

    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 {
        StreamConfigControlHandle { 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 StreamConfigRequestStream {
    type Item = Result<StreamConfigRequest, 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 StreamConfigRequestStream 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 {
                    0x4e146d6bca733a84 => {
                        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 =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::GetHealthState {
                            responder: StreamConfigGetHealthStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa81907ce6066295 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::SignalProcessingConnect {
                            protocol: req.protocol,

                            control_handle,
                        })
                    }
                    0x7d89c02f3e2d3c01 => {
                        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 =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::GetProperties {
                            responder: StreamConfigGetPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x448efa7850cafe7e => {
                        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 =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::GetSupportedFormats {
                            responder: StreamConfigGetSupportedFormatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2afb19dd13faa1ba => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamConfigCreateRingBufferRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamConfigCreateRingBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::CreateRingBuffer {
                            format: req.format,
                            ring_buffer: req.ring_buffer,

                            control_handle,
                        })
                    }
                    0x4772506136ab65c1 => {
                        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 =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::WatchGainState {
                            responder: StreamConfigWatchGainStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3943b41498c6a384 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamConfigSetGainRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamConfigSetGainRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::SetGain {
                            target_state: req.target_state,

                            control_handle,
                        })
                    }
                    0x497345a6f048b2a6 => {
                        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 =
                            StreamConfigControlHandle { inner: this.inner.clone() };
                        Ok(StreamConfigRequest::WatchPlugState {
                            responder: StreamConfigWatchPlugStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamConfigMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview see
/// [Audio Driver Streaming Interface](https://fuchsia.dev/fuchsia-src/development/audio/drivers/streaming)
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum StreamConfigRequest {
    /// Retrieves top level health state.
    /// A driver not responding promptly can be used as an indication of an unhealthy driver.
    GetHealthState { responder: StreamConfigGetHealthStateResponder },
    /// Connect to a `SignalProcessing` protocol.
    /// Multiple connections may be supported, if a new connection request is not supported, i.e.
    /// the maximum number of connections have already been created, for instance one, then the
    /// `protocol` channel (not the channel upon which `SignalProcessingConnect` is being called)
    /// will be closed with a `ZX_ERR_ALREADY_BOUND` epitaph.
    /// If signal processing is not supported at all, then the `protocol` channel (again, not the
    /// channel upon which `SignalProcessingConnect` is being called) will be closed with a
    /// `ZX_ERR_NOT_SUPPORTED` epitaph.
    /// This method is named `SignalProcessingConnect` instead of `Connect` because this protocol
    /// is intended to be composed, and hence the more verbose name allows differentiation and
    /// improved clarity.
    SignalProcessingConnect {
        protocol: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        control_handle: StreamConfigControlHandle,
    },
    /// Retrieves top level static properties.
    GetProperties { responder: StreamConfigGetPropertiesResponder },
    /// Gets formats supported by a given driver. When not all combinations supported by the
    /// driver can be described with one `SupportedFormats`, the driver returns more than one
    /// `SupportedFormats` in the returned vector. For example, if one `SupportedFormats` allows
    /// for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
    /// 96KHz, then the driver replies with 2 `SupportedFormats`: <<32bits>,<48KHz>> and
    /// <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
    /// bits per sample. In the case where the driver supports either 16 or 32 bits samples at
    /// either 48 or 96KHz, the driver would reply with 1 `SupportedFormats`:
    /// <<16bits,32bits>,<48KHz,96KHz>>.
    GetSupportedFormats { responder: StreamConfigGetSupportedFormatsResponder },
    /// `CreateRingBuffer` is sent by clients to select a stream format based on information that
    /// the driver provides in `GetSupportedFormats` what is supported by the client, and any other
    /// requirement. The `ring_buffer` channel is used to control the audio buffer, if a previous
    /// ring buffer channel had been established and was still active, the driver must close that
    /// (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
    /// operations in the process.
    CreateRingBuffer {
        format: Format,
        ring_buffer: fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        control_handle: StreamConfigControlHandle,
    },
    /// Get the gain state via a hanging get. The driver will reply to the first `WatchGainState`
    /// sent by the client and this reply must include a `gain_db` set to 0dB or lower. The driver
    /// will not respond to subsequent client `WatchGainState` calls until the gain state changes
    /// from what was most recently reported.
    /// If `WatchGainState` is called for a second time before the first call has completed, then
    /// the protocol channel must be closed with the error `ZX_ERR_BAD_STATE`.
    WatchGainState { responder: StreamConfigWatchGainStateResponder },
    /// Client update of the gain state.
    SetGain { target_state: GainState, control_handle: StreamConfigControlHandle },
    /// Get the plug detect state via a hanging get. The driver will reply to the first
    /// `WatchPlugState` sent by the client. The driver will not respond to subsequent client
    /// `WatchPlugState` calls until the plug state changes from what was most recently reported.
    /// If `WatchPlugState` is called for a second time before the first call has completed, then
    /// the protocol channel must be closed with the error `ZX_ERR_BAD_STATE`.
    WatchPlugState { responder: StreamConfigWatchPlugStateResponder },
}

impl StreamConfigRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_health_state(self) -> Option<(StreamConfigGetHealthStateResponder)> {
        if let StreamConfigRequest::GetHealthState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_processing_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
        StreamConfigControlHandle,
    )> {
        if let StreamConfigRequest::SignalProcessingConnect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_properties(self) -> Option<(StreamConfigGetPropertiesResponder)> {
        if let StreamConfigRequest::GetProperties { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_supported_formats(self) -> Option<(StreamConfigGetSupportedFormatsResponder)> {
        if let StreamConfigRequest::GetSupportedFormats { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_ring_buffer(
        self,
    ) -> Option<(
        Format,
        fdomain_client::fidl::ServerEnd<RingBufferMarker>,
        StreamConfigControlHandle,
    )> {
        if let StreamConfigRequest::CreateRingBuffer { format, ring_buffer, control_handle } = self
        {
            Some((format, ring_buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_gain_state(self) -> Option<(StreamConfigWatchGainStateResponder)> {
        if let StreamConfigRequest::WatchGainState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_gain(self) -> Option<(GainState, StreamConfigControlHandle)> {
        if let StreamConfigRequest::SetGain { target_state, control_handle } = self {
            Some((target_state, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_plug_state(self) -> Option<(StreamConfigWatchPlugStateResponder)> {
        if let StreamConfigRequest::WatchPlugState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamConfigRequest::GetHealthState { .. } => "get_health_state",
            StreamConfigRequest::SignalProcessingConnect { .. } => "signal_processing_connect",
            StreamConfigRequest::GetProperties { .. } => "get_properties",
            StreamConfigRequest::GetSupportedFormats { .. } => "get_supported_formats",
            StreamConfigRequest::CreateRingBuffer { .. } => "create_ring_buffer",
            StreamConfigRequest::WatchGainState { .. } => "watch_gain_state",
            StreamConfigRequest::SetGain { .. } => "set_gain",
            StreamConfigRequest::WatchPlugState { .. } => "watch_plug_state",
        }
    }
}

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

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

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

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

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

impl StreamConfigControlHandle {}

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

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

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

    fn send_raw(&self, mut state: &HealthState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HealthGetHealthStateResponse>(
            (state,),
            self.tx_id,
            0x4e146d6bca733a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut properties: &StreamProperties) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StreamConfigGetPropertiesResponse>(
            (properties,),
            self.tx_id,
            0x7d89c02f3e2d3c01,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut supported_formats: &[SupportedFormats]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StreamConfigGetSupportedFormatsResponse>(
            (supported_formats,),
            self.tx_id,
            0x448efa7850cafe7e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut gain_state: &GainState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StreamConfigWatchGainStateResponse>(
            (gain_state,),
            self.tx_id,
            0x4772506136ab65c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut plug_state: &PlugState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StreamConfigWatchPlugStateResponse>(
            (plug_state,),
            self.tx_id,
            0x497345a6f048b2a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for StreamConfigConnectorMarker {
    type Proxy = StreamConfigConnectorProxy;
    type RequestStream = StreamConfigConnectorRequestStream;

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

pub trait StreamConfigConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        protocol: fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for StreamConfigConnectorProxy {
    type Protocol = StreamConfigConnectorMarker;

    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 StreamConfigConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/StreamConfigConnector.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <StreamConfigConnectorMarker 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) -> StreamConfigConnectorEventStream {
        StreamConfigConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect to a `StreamConfig` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    pub fn r#connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        StreamConfigConnectorProxyInterface::r#connect(self, protocol)
    }
}

impl StreamConfigConnectorProxyInterface for StreamConfigConnectorProxy {
    fn r#connect(
        &self,
        mut protocol: fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigConnectorConnectRequest>(
            (protocol,),
            0x22051ff3021eafec,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for StreamConfigConnectorRequestStream {
    type Protocol = StreamConfigConnectorMarker;
    type ControlHandle = StreamConfigConnectorControlHandle;

    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 {
        StreamConfigConnectorControlHandle { 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 StreamConfigConnectorRequestStream {
    type Item = Result<StreamConfigConnectorRequest, 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 StreamConfigConnectorRequestStream 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 {
                0x22051ff3021eafec => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(StreamConfigConnectorConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamConfigConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamConfigConnectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamConfigConnectorRequest::Connect {protocol: req.protocol,

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

/// For an overview see
/// [Audio Driver Streaming Interface](https://fuchsia.dev/fuchsia-src/development/audio/drivers/streaming).
/// # Deprecation
///
/// Not supported anymore, instead use an
/// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
/// with one Ring Buffer, see
/// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
#[derive(Debug)]
pub enum StreamConfigConnectorRequest {
    /// Connect to a `StreamConfig` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    Connect {
        protocol: fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
        control_handle: StreamConfigConnectorControlHandle,
    },
}

impl StreamConfigConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<StreamConfigMarker>,
        StreamConfigConnectorControlHandle,
    )> {
        if let StreamConfigConnectorRequest::Connect { protocol, control_handle } = self {
            Some((protocol, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl StreamConfigConnectorControlHandle {}

mod internal {
    use super::*;

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            CompositeCreatePacketStreamRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CompositeCreatePacketStreamRequest
    {
        #[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::<CompositeCreatePacketStreamRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CompositeCreatePacketStreamRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.processing_element_id),
                    <Format2 as fidl::encoding::ValueTypeMarker>::borrow(&self.format),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.packet_stream_control,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<Format2, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CompositeCreatePacketStreamRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[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::<CompositeCreatePacketStreamRequest>(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(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for CompositeCreatePacketStreamRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                processing_element_id: fidl::new_empty!(
                    u64,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                format: fidl::new_empty!(Format2, fdomain_client::fidl::FDomainResourceDialect),
                packet_stream_control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
                    >,
                    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(24) };
            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 + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.processing_element_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Format2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.format,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<PacketStreamControlMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.packet_stream_control,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            CompositeCreateRingBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CompositeCreateRingBufferRequest
    {
        #[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::<CompositeCreateRingBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeCreateRingBufferRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.processing_element_id),
                    <Format2 as fidl::encoding::ValueTypeMarker>::borrow(&self.format),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ring_buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<Format2, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CompositeCreateRingBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[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::<CompositeCreateRingBufferRequest>(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(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for CompositeCreateRingBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                processing_element_id: fidl::new_empty!(
                    u64,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                format: fidl::new_empty!(Format2, fdomain_client::fidl::FDomainResourceDialect),
                ring_buffer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                    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(24) };
            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 + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.processing_element_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Format2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.format,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.ring_buffer,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DaiCreateRingBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DaiCreateRingBufferRequest
    {
        #[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::<DaiCreateRingBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DaiCreateRingBufferRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <DaiFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.dai_format),
                    <Format as fidl::encoding::ValueTypeMarker>::borrow(&self.ring_buffer_format),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ring_buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<DaiFormat, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<Format, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DaiCreateRingBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[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::<DaiCreateRingBufferRequest>(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(64);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 48, depth)?;
            self.2.encode(encoder, offset + 64, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DaiCreateRingBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dai_format: fidl::new_empty!(
                    DaiFormat,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                ring_buffer_format: fidl::new_empty!(
                    Format,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                ring_buffer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                    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(64) };
            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 + 64 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                DaiFormat,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dai_format,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Format,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.ring_buffer_format,
                decoder,
                offset + 48,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RingBufferMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.ring_buffer,
                decoder,
                offset + 64,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RingBufferGetVmoResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RingBufferGetVmoResponse
    {
        #[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::<RingBufferGetVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RingBufferGetVmoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_frames),
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.ring_buffer
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RingBufferGetVmoResponse,
            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::<RingBufferGetVmoResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RingBufferGetVmoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                num_frames: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                ring_buffer: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for PacketStreamControlSetPacketStreamSinkRequest {
        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 PacketStreamControlSetPacketStreamSinkRequest {
        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<
            PacketStreamControlSetPacketStreamSinkRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PacketStreamControlSetPacketStreamSinkRequest
    {
        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::<PacketStreamControlSetPacketStreamSinkRequest>(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<PacketStreamSinkMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.stream.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for PacketStreamControlSetPacketStreamSinkRequest
    {
        #[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<PacketStreamSinkMarker>,
                > 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.stream.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                    >,
                    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 PacketStreamControlGetPacketStreamSinkResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.stream {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PacketStreamControlGetPacketStreamSinkResponse {
        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 PacketStreamControlGetPacketStreamSinkResponse {
        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<
            PacketStreamControlGetPacketStreamSinkResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PacketStreamControlGetPacketStreamSinkResponse
    {
        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::<PacketStreamControlGetPacketStreamSinkResponse>(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<PacketStreamSinkMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.stream.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for PacketStreamControlGetPacketStreamSinkResponse
    {
        #[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<PacketStreamSinkMarker>,
                > 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.stream.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<PacketStreamSinkMarker>,
                    >,
                    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 PacketStreamSinkPutPacketRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.payload {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PacketStreamSinkPutPacketRequest {
        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 PacketStreamSinkPutPacketRequest {
        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<
            PacketStreamSinkPutPacketRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut PacketStreamSinkPutPacketRequest
    {
        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::<PacketStreamSinkPutPacketRequest>(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::<
                DataTransfer,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.payload
                    .as_mut()
                    .map(<DataTransfer as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for PacketStreamSinkPutPacketRequest
    {
        #[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 =
                    <DataTransfer 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.payload.get_or_insert_with(|| {
                    fidl::new_empty!(DataTransfer, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    DataTransfer,
                    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 RegisterVmosConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.vmo_infos {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RegisterVmosConfig {
        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 RegisterVmosConfig {
        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<RegisterVmosConfig, fdomain_client::fidl::FDomainResourceDialect>
        for &mut RegisterVmosConfig
    {
        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::<RegisterVmosConfig>(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::Vector<VmoInfo, 256>, fdomain_client::fidl::FDomainResourceDialect>(
            self.vmo_infos.as_mut().map(<fidl::encoding::Vector<VmoInfo, 256> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RegisterVmosConfig
    {
        #[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::Vector<VmoInfo, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.vmo_infos.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<VmoInfo, 256>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<VmoInfo, 256>, 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 VmoInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.vmo {
                return 2;
            }
            if let Some(_) = self.id {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.vmo.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

            // 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 VmoTransfer {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.payload_size {
                return 3;
            }
            if let Some(_) = self.vmo_offset {
                return 2;
            }
            if let Some(_) = self.vmo_id {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

            // 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 DataTransfer {
        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 DataTransfer {
        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<DataTransfer, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DataTransfer
    {
        #[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::<DataTransfer>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                DataTransfer::VmoTransfer(ref mut val) => fidl::encoding::encode_in_envelope::<
                    VmoTransfer,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <VmoTransfer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                DataTransfer::InlineData(ref val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Vector<u8, 8192>,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                DataTransfer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

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