fidl_fuchsia_hardware_audio/

fidl_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 fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_hardware_audio__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CodecMarker {
    type Proxy = CodecProxy;
    type RequestStream = CodecRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CodecSynchronousProxy;

    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: fidl::endpoints::ServerEnd<
            fidl_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)]
#[cfg(target_os = "fuchsia")]
pub struct CodecSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CodecSynchronousProxy {
    type Proxy = CodecProxy;
    type Protocol = CodecMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HealthState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, HealthGetHealthStateResponse>(
                (),
                0x4e146d6bca733a84,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// 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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x50757ae579a7bd6b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CodecProperties, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, CodecGetPropertiesResponse>(
                (),
                0x7a0d138a6a1d9d90,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.properties)
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<i64, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, CodecStopResponse>(
            (),
            0x5c2e380df1332dbd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.stop_time)
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<i64, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, CodecStartResponse>(
                (),
                0x329cdacb286ab00,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.start_time)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CodecGetDaiFormatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<CodecGetDaiFormatsResponse, i32>,
        >(
            (),
            0xf8bbc46b4ba6a52,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.formats))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CodecSetDaiFormatResult, fidl::Error> {
        let _response = self.client.send_query::<
            CodecSetDaiFormatRequest,
            fidl::encoding::ResultType<CodecSetDaiFormatResponse, i32>,
        >(
            (format,),
            0x2f829df9e5a7a1ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.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.
    pub fn r#watch_plug_state(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PlugState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, CodecWatchPlugStateResponse>(
                (),
                0x182b87f935ca7326,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.plug_state)
    }
}

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

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

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

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

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

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

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

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

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

impl CodecProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Codec.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CodecMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::ServerEnd<
            fidl_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<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        CodecProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        CodecProperties,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        CodecProxyInterface::r#watch_plug_state(self)
    }
}

impl CodecProxyInterface for CodecProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ResetResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#reset(&self) -> Self::ResetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CodecGetPropertiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#stop(&self) -> Self::StopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CodecStopResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(&self) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CodecStartResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecGetDaiFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecGetDaiFormatsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_dai_format(&self, mut format: &DaiFormat) -> Self::SetDaiFormatResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecSetDaiFormatResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecSetDaiFormatResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_plug_state(&self) -> Self::WatchPlugStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PlugState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CodecWatchPlugStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e146d6bca733a84 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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!(fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::endpoints::ServerEnd<
            fidl_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<(
        fidl::endpoints::ServerEnd<
            fidl_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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for CodecConnectorMarker {
    type Proxy = CodecConnectorProxy;
    type RequestStream = CodecConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CodecConnectorSynchronousProxy;

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

pub trait CodecConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        codec_protocol: fidl::endpoints::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CodecConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CodecConnectorSynchronousProxy {
    type Proxy = CodecConnectorProxy;
    type Protocol = CodecConnectorMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CodecConnectorConnectRequest>(
            (codec_protocol,),
            0x1413f551544026c9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl CodecConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/CodecConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CodecConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error> {
        CodecConnectorProxyInterface::r#connect(self, codec_protocol)
    }
}

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

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1413f551544026c9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            CodecConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview of the Codec protocols see
/// [Codec Interface](//docs/concepts/drivers/driver_architectures/audio_drivers/audio_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: fidl::endpoints::ServerEnd<CodecMarker>,
        control_handle: CodecConnectorControlHandle,
    },
}

impl CodecConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl CodecConnectorControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for CompositeMarker {
    type Proxy = CompositeProxy;
    type RequestStream = CompositeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CompositeSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Composite";
}
pub type CompositeResetResult = Result<(), DriverError>;
pub type CompositeGetRingBufferFormatsResult = Result<Vec<SupportedFormats>, DriverError>;
pub type CompositeCreateRingBufferResult = Result<(), DriverError>;
pub type CompositeGetDaiFormatsResult = Result<Vec<DaiSupportedFormats>, DriverError>;
pub type CompositeSetDaiFormatResult = 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: fidl::endpoints::ServerEnd<
            fidl_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: &Format,
        ring_buffer: fidl::endpoints::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;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CompositeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CompositeSynchronousProxy {
    type Proxy = CompositeProxy;
    type Protocol = CompositeMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HealthState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, HealthGetHealthStateResponse>(
                (),
                0x4e146d6bca733a84,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// 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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Resets the hardware including all DAI interconnects and signal processing.
    /// As a result, all channels obtained by `CreateRingBuffer` 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.
    ///
    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeResetResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, DriverError>,
        >(
            (),
            0xac355fb98341996,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeProperties, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, CompositeGetPropertiesResponse>(
                (),
                0x31846fa0a459942b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.properties)
    }

    /// 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 `SupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats` may be supported.
    pub fn r#get_ring_buffer_formats(
        &self,
        mut processing_element_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeGetRingBufferFormatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            CompositeGetRingBufferFormatsRequest,
            fidl::encoding::ResultType<CompositeGetRingBufferFormatsResponse, DriverError>,
        >(
            (processing_element_id,),
            0x1d89b701b6816ac4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.ring_buffer_formats))
    }

    /// `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`.
    pub fn r#create_ring_buffer(
        &self,
        mut processing_element_id: u64,
        mut format: &Format,
        mut ring_buffer: fidl::endpoints::ServerEnd<RingBufferMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeCreateRingBufferResult, fidl::Error> {
        let _response = self.client.send_query::<
            CompositeCreateRingBufferRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, DriverError>,
        >(
            (processing_element_id, format, ring_buffer,),
            0x28c5685f85262033,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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 SupportedFormats may be supported.
    pub fn r#get_dai_formats(
        &self,
        mut processing_element_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeGetDaiFormatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            CompositeGetDaiFormatsRequest,
            fidl::encoding::ResultType<CompositeGetDaiFormatsResponse, DriverError>,
        >(
            (processing_element_id,),
            0x3cbeaed59c8f69b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.dai_formats))
    }

    /// `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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CompositeSetDaiFormatResult, fidl::Error> {
        let _response = self.client.send_query::<
            CompositeSetDaiFormatRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, DriverError>,
        >(
            (processing_element_id, format,),
            0x155acf5cc0dc8a84,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

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

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

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

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

impl CompositeProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Composite.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CompositeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::ServerEnd<
            fidl_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` 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.
    ///
    /// 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CompositeProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<
        CompositeProperties,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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 `SupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats` may be supported.
    pub fn r#get_ring_buffer_formats(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<
        CompositeGetRingBufferFormatsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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`.
    pub fn r#create_ring_buffer(
        &self,
        mut processing_element_id: u64,
        mut format: &Format,
        mut ring_buffer: fidl::endpoints::ServerEnd<RingBufferMarker>,
    ) -> fidl::client::QueryResponseFut<
        CompositeCreateRingBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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 SupportedFormats may be supported.
    pub fn r#get_dai_formats(
        &self,
        mut processing_element_id: u64,
    ) -> fidl::client::QueryResponseFut<
        CompositeGetDaiFormatsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CompositeProxyInterface::r#set_dai_format(self, processing_element_id, format)
    }
}

impl CompositeProxyInterface for CompositeProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e146d6bca733a84 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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!(fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CompositeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The `Composite` interface is a FIDL protocol exposed by audio drivers. The `Composite` interface
/// is generic and allows the configuration of various audio hardware types including those supported
/// by the `StreamConfig`, `Dai` and `Codec` FIDL interfaces. The `Composite` interface is more
/// generic and provides more flexible routing within audio subsystems. Also see
/// [Audio Driver Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite.md)
/// The hardware abstracted by the Composite protocol will be turned off (placed in its lowest
/// supported power state) until a call to any APIs that requires the hardware to be turned on
/// (placed in a higher power state).
#[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: fidl::endpoints::ServerEnd<
            fidl_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` 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.
    ///
    /// 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 `SupportedFormats` allows for cases where exclusive combinations of
    /// the parameters in `SupportedFormats` may be supported.
    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`.
    CreateRingBuffer {
        processing_element_id: u64,
        format: Format,
        ring_buffer: fidl::endpoints::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 SupportedFormats may be supported.
    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,
    },
}

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<(
        fidl::endpoints::ServerEnd<
            fidl_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,
        Format,
        fidl::endpoints::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
        }
    }

    /// 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",
        }
    }
}

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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::ResultType<
            fidl::encoding::EmptyStruct,
            DriverError,
        >>(
            result,
            self.tx_id,
            0xac355fb98341996,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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::<CompositeGetPropertiesResponse>(
            (properties,),
            self.tx_id,
            0x31846fa0a459942b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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<&[SupportedFormats], 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<&[SupportedFormats], DriverError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

#[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 fidl::endpoints::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::ResultType<
            fidl::encoding::EmptyStruct,
            DriverError,
        >>(
            result,
            self.tx_id,
            0x28c5685f85262033,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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::ResultType<
            CompositeGetDaiFormatsResponse,
            DriverError,
        >>(
            result.map(|dai_formats| (dai_formats,)),
            self.tx_id,
            0x3cbeaed59c8f69b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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::ResultType<
            fidl::encoding::EmptyStruct,
            DriverError,
        >>(
            result,
            self.tx_id,
            0x155acf5cc0dc8a84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for CompositeConnectorMarker {
    type Proxy = CompositeConnectorProxy;
    type RequestStream = CompositeConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CompositeConnectorSynchronousProxy;

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

pub trait CompositeConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        composite_protocol: fidl::endpoints::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CompositeConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CompositeConnectorSynchronousProxy {
    type Proxy = CompositeConnectorProxy;
    type Protocol = CompositeConnectorMarker;

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

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

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

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

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

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

    /// Connect to a `Device` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    pub fn r#connect(
        &self,
        mut composite_protocol: fidl::endpoints::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CompositeConnectorConnectRequest>(
            (composite_protocol,),
            0x7ee557529079e466,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl CompositeConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/CompositeConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <CompositeConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

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

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

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x7ee557529079e466 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CompositeConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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 `Device` protocol.
    /// This method allows a component to serve FIDL outside the devhost's control.
    Connect {
        composite_protocol: fidl::endpoints::ServerEnd<CompositeMarker>,
        control_handle: CompositeConnectorControlHandle,
    },
}

impl CompositeConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl CompositeConnectorControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for DaiMarker {
    type Proxy = DaiProxy;
    type RequestStream = DaiRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DaiSynchronousProxy;

    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: fidl::endpoints::ServerEnd<
            fidl_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: fidl::endpoints::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DaiSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DaiSynchronousProxy {
    type Proxy = DaiProxy;
    type Protocol = DaiMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HealthState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, HealthGetHealthStateResponse>(
                (),
                0x4e146d6bca733a84,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// 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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x69e5fa9fa2f78c14,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DaiProperties, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DaiGetPropertiesResponse>(
                (),
                0x2c25a1a66149510b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.properties)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DaiGetDaiFormatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DaiGetDaiFormatsResponse, i32>,
        >(
            (),
            0x1eb37b0cddf79d69,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.dai_formats))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DaiGetRingBufferFormatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DaiGetRingBufferFormatsResponse, i32>,
        >(
            (),
            0x760371081d8c92e4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.ring_buffer_formats))
    }

    /// `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: fidl::endpoints::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DaiCreateRingBufferRequest>(
            (dai_format, ring_buffer_format, ring_buffer),
            0x5af9760589a75257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl DaiProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Dai.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DaiMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::ServerEnd<
            fidl_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<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DaiProxyInterface::r#reset(self)
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
    ) -> fidl::client::QueryResponseFut<DaiProperties, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::endpoints::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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ResetResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#reset(&self) -> Self::ResetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DaiProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DaiGetPropertiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_dai_formats(&self) -> Self::GetDaiFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DaiGetDaiFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DaiGetDaiFormatsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ring_buffer_formats(&self) -> Self::GetRingBufferFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DaiGetRingBufferFormatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DaiGetRingBufferFormatsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e146d6bca733a84 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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!(fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview see
/// [Digital Audio Interface](https://fuchsia.dev/fuchsia-src/concepts/drivers/driver_architectures/audio_drivers/audio_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: fidl::endpoints::ServerEnd<
            fidl_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: fidl::endpoints::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<(
        fidl::endpoints::ServerEnd<
            fidl_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, fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for DaiConnectorMarker {
    type Proxy = DaiConnectorProxy;
    type RequestStream = DaiConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DaiConnectorSynchronousProxy;

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

pub trait DaiConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        dai_protocol: fidl::endpoints::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DaiConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DaiConnectorSynchronousProxy {
    type Proxy = DaiConnectorProxy;
    type Protocol = DaiConnectorMarker;

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

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

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

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

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

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

    /// This connects to a DAI protocol server.
    pub fn r#connect(
        &self,
        mut dai_protocol: fidl::endpoints::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DaiConnectorConnectRequest>(
            (dai_protocol,),
            0x4e4db05c2eca1450,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl DaiConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/DaiConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DaiConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

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

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

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e4db05c2eca1450 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DaiConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview of the DAI protocols see
/// [Digital Audio Interface](//docs/concepts/drivers/driver_architectures/audio_drivers/audio_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: fidl::endpoints::ServerEnd<DaiMarker>,
        control_handle: DaiConnectorControlHandle,
    },
}

impl DaiConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl DaiConnectorControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for HealthMarker {
    type Proxy = HealthProxy;
    type RequestStream = HealthRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HealthSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct HealthSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HealthSynchronousProxy {
    type Proxy = HealthProxy;
    type Protocol = HealthMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HealthState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, HealthGetHealthStateResponse>(
                (),
                0x4e146d6bca733a84,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }
}

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

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

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

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

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

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

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

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

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

impl HealthProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/Health.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HealthMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl HealthProxyInterface for HealthProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 RingBufferMarker;

impl fidl::endpoints::ProtocolMarker for RingBufferMarker {
    type Proxy = RingBufferProxy;
    type RequestStream = RingBufferRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RingBufferSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) RingBuffer";
}
pub type RingBufferGetVmoResult = Result<(u32, fidl::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)]
#[cfg(target_os = "fuchsia")]
pub struct RingBufferSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RingBufferSynchronousProxy {
    type Proxy = RingBufferProxy;
    type Protocol = RingBufferMarker;

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

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

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

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

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

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

    /// Accessor for top level static properties.
    pub fn r#get_properties(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RingBufferProperties, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, RingBufferGetPropertiesResponse>(
                (),
                0x12947f061a8fe1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.properties)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RingBufferPositionInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            RingBufferWatchClockRecoveryPositionInfoResponse,
        >(
            (),
            0x694d5b898a4167e5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.position_info)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RingBufferGetVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            RingBufferGetVmoRequest,
            fidl::encoding::ResultType<RingBufferGetVmoResponse, GetVmoError>,
        >(
            (min_frames, clock_recovery_notifications_per_ring,),
            0x44c8f4f5680e853a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.num_frames, x.ring_buffer)))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<i64, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, RingBufferStartResponse>(
                (),
                0x5dd780a769a8892d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.start_time)
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x49a73d9cf1d4e110,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RingBufferSetActiveChannelsResult, fidl::Error> {
        let _response = self.client.send_query::<
            RingBufferSetActiveChannelsRequest,
            fidl::encoding::ResultType<RingBufferSetActiveChannelsResponse, i32>,
        >(
            (active_channels_bitmask,),
            0x605464c1d384f309,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.set_time))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DelayInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<RingBufferWatchDelayInfoResponse>,
        >(
            (),
            0x6c1248db213fcf9f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<RingBufferMarker>("watch_delay_info")?;
        Ok(_response.delay_info)
    }
}

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

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

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

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

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

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

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

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

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

impl RingBufferProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/RingBuffer.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <RingBufferMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl RingBufferProxyInterface for RingBufferProxy {
    type GetPropertiesResponseFut = fidl::client::QueryResponseFut<
        RingBufferProperties,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RingBufferGetPropertiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_clock_recovery_position_info(
        &self,
    ) -> Self::WatchClockRecoveryPositionInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferPositionInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RingBufferWatchClockRecoveryPositionInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_vmo(
        &self,
        mut min_frames: u32,
        mut clock_recovery_notifications_per_ring: u32,
    ) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RingBufferGetVmoResponse, GetVmoError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start(&self) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RingBufferStartResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#stop(&self) -> Self::StopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_active_channels(
        &self,
        mut active_channels_bitmask: u64,
    ) -> Self::SetActiveChannelsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RingBufferSetActiveChannelsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RingBufferSetActiveChannelsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_delay_info(&self) -> Self::WatchDelayInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DelayInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<RingBufferWatchDelayInfoResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c1248db213fcf9f,
            >(_buf?)?
            .into_result::<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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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, fidl::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, fidl::Vmo), GetVmoError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(u32, fidl::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for StreamConfigMarker {
    type Proxy = StreamConfigProxy;
    type RequestStream = StreamConfigRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamConfigSynchronousProxy;

    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: fidl::endpoints::ServerEnd<
            fidl_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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamConfigSynchronousProxy {
    type Proxy = StreamConfigProxy;
    type Protocol = StreamConfigMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HealthState, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, HealthGetHealthStateResponse>(
                (),
                0x4e146d6bca733a84,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.state)
    }

    /// 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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Retrieves top level static properties.
    pub fn r#get_properties(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamProperties, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, StreamConfigGetPropertiesResponse>(
                (),
                0x7d89c02f3e2d3c01,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.properties)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<SupportedFormats>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, StreamConfigGetSupportedFormatsResponse>(
                (),
                0x448efa7850cafe7e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.supported_formats)
    }

    /// `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: fidl::endpoints::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigCreateRingBufferRequest>(
            (format, ring_buffer),
            0x2afb19dd13faa1ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GainState, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, StreamConfigWatchGainStateResponse>(
                (),
                0x4772506136ab65c1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.gain_state)
    }

    /// Client update of the gain state.
    pub fn r#set_gain(&self, mut target_state: &GainState) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigSetGainRequest>(
            (target_state,),
            0x3943b41498c6a384,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PlugState, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, StreamConfigWatchPlugStateResponse>(
                (),
                0x497345a6f048b2a6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.plug_state)
    }
}

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

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

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

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

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

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

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

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

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

impl StreamConfigProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/StreamConfig.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::ServerEnd<
            fidl_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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::endpoints::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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        StreamConfigProxyInterface::r#watch_plug_state(self)
    }
}

impl StreamConfigProxyInterface for StreamConfigProxy {
    type GetHealthStateResponseFut =
        fidl::client::QueryResponseFut<HealthState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_health_state(&self) -> Self::GetHealthStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HealthState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HealthGetHealthStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_audio_signalprocessing::SignalProcessingMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest>(
            (protocol,),
            0xa81907ce6066295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetPropertiesResponseFut = fidl::client::QueryResponseFut<
        StreamProperties,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_properties(&self) -> Self::GetPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamProperties, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamConfigGetPropertiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_supported_formats(&self) -> Self::GetSupportedFormatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<SupportedFormats>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamConfigGetSupportedFormatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<RingBufferMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigCreateRingBufferRequest>(
            (format, ring_buffer),
            0x2afb19dd13faa1ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchGainStateResponseFut =
        fidl::client::QueryResponseFut<GainState, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_gain_state(&self) -> Self::WatchGainStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GainState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamConfigWatchGainStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_plug_state(&self) -> Self::WatchPlugStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PlugState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamConfigWatchPlugStateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e146d6bca733a84 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            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!(fidl_fuchsia_hardware_audio_signalprocessing::ConnectorSignalProcessingConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// For an overview see
/// [Audio Driver Streaming Interface](https://fuchsia.dev/fuchsia-src/concepts/drivers/driver_architectures/audio_drivers/audio_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: fidl::endpoints::ServerEnd<
            fidl_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: fidl::endpoints::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<(
        fidl::endpoints::ServerEnd<
            fidl_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, fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for StreamConfigConnectorMarker {
    type Proxy = StreamConfigConnectorProxy;
    type RequestStream = StreamConfigConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamConfigConnectorSynchronousProxy;

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

pub trait StreamConfigConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        protocol: fidl::endpoints::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamConfigConnectorSynchronousProxy {
    type Proxy = StreamConfigConnectorProxy;
    type Protocol = StreamConfigConnectorMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamConfigConnectorConnectRequest>(
            (protocol,),
            0x22051ff3021eafec,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl StreamConfigConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.audio/StreamConfigConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <StreamConfigConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

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

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x22051ff3021eafec => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(StreamConfigConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// For an overview see
/// [Audio Driver Streaming Interface](https://fuchsia.dev/fuchsia-src/concepts/drivers/driver_architectures/audio_drivers/audio_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: fidl::endpoints::ServerEnd<StreamConfigMarker>,
        control_handle: StreamConfigConnectorControlHandle,
    },
}

impl StreamConfigConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

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

impl StreamConfigConnectorControlHandle {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for CodecConnectorServiceMarker {
    type Proxy = CodecConnectorServiceProxy;
    type Request = CodecConnectorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.CodecConnectorService";
}

/// A request for one of the member protocols of CodecConnectorService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum CodecConnectorServiceRequest {
    CodecConnector(CodecConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for CodecConnectorServiceRequest {
    type Service = CodecConnectorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "codec_connector" => Self::CodecConnector(
                <CodecConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service CodecConnectorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["codec_connector"]
    }
}
/// # 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)
#[cfg(target_os = "fuchsia")]
pub struct CodecConnectorServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for CodecConnectorServiceProxy {
    type Service = CodecConnectorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl CodecConnectorServiceProxy {
    pub fn connect_to_codec_connector(&self) -> Result<CodecConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CodecConnectorMarker>();
        self.connect_channel_to_codec_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_codec_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_codec_connector`] for more details.
    pub fn connect_to_codec_connector_sync(
        &self,
    ) -> Result<CodecConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CodecConnectorMarker>();
        self.connect_channel_to_codec_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_codec_connector`, but accepts a server end.
    /// See [`Self::connect_to_codec_connector`] for more details.
    pub fn connect_channel_to_codec_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<CodecConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("codec_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for CodecServiceMarker {
    type Proxy = CodecServiceProxy;
    type Request = CodecServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.CodecService";
}

/// A request for one of the member protocols of CodecService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum CodecServiceRequest {
    Codec(CodecRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for CodecServiceRequest {
    type Service = CodecServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "codec" => Self::Codec(
                <CodecRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service CodecService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["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)
#[cfg(target_os = "fuchsia")]
pub struct CodecServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for CodecServiceProxy {
    type Service = CodecServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl CodecServiceProxy {
    pub fn connect_to_codec(&self) -> Result<CodecProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CodecMarker>();
        self.connect_channel_to_codec(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_codec`, but returns a sync proxy.
    /// See [`Self::connect_to_codec`] for more details.
    pub fn connect_to_codec_sync(&self) -> Result<CodecSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CodecMarker>();
        self.connect_channel_to_codec(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_codec`, but accepts a server end.
    /// See [`Self::connect_to_codec`] for more details.
    pub fn connect_channel_to_codec(
        &self,
        server_end: fidl::endpoints::ServerEnd<CodecMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("codec", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for CompositeConnectorServiceMarker {
    type Proxy = CompositeConnectorServiceProxy;
    type Request = CompositeConnectorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.CompositeConnectorService";
}

/// A request for one of the member protocols of CompositeConnectorService.
///
#[cfg(target_os = "fuchsia")]
pub enum CompositeConnectorServiceRequest {
    CompositeConnector(CompositeConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for CompositeConnectorServiceRequest {
    type Service = CompositeConnectorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "composite_connector" => Self::CompositeConnector(
                <CompositeConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service CompositeConnectorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["composite_connector"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct CompositeConnectorServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for CompositeConnectorServiceProxy {
    type Service = CompositeConnectorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl CompositeConnectorServiceProxy {
    pub fn connect_to_composite_connector(&self) -> Result<CompositeConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CompositeConnectorMarker>();
        self.connect_channel_to_composite_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_composite_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_composite_connector`] for more details.
    pub fn connect_to_composite_connector_sync(
        &self,
    ) -> Result<CompositeConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CompositeConnectorMarker>();
        self.connect_channel_to_composite_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_composite_connector`, but accepts a server end.
    /// See [`Self::connect_to_composite_connector`] for more details.
    pub fn connect_channel_to_composite_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<CompositeConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("composite_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DaiConnectorServiceMarker {
    type Proxy = DaiConnectorServiceProxy;
    type Request = DaiConnectorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.DaiConnectorService";
}

/// A request for one of the member protocols of DaiConnectorService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum DaiConnectorServiceRequest {
    DaiConnector(DaiConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for DaiConnectorServiceRequest {
    type Service = DaiConnectorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "dai_connector" => Self::DaiConnector(
                <DaiConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service DaiConnectorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["dai_connector"]
    }
}
/// # 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)
#[cfg(target_os = "fuchsia")]
pub struct DaiConnectorServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for DaiConnectorServiceProxy {
    type Service = DaiConnectorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl DaiConnectorServiceProxy {
    pub fn connect_to_dai_connector(&self) -> Result<DaiConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DaiConnectorMarker>();
        self.connect_channel_to_dai_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_dai_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_dai_connector`] for more details.
    pub fn connect_to_dai_connector_sync(
        &self,
    ) -> Result<DaiConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DaiConnectorMarker>();
        self.connect_channel_to_dai_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_dai_connector`, but accepts a server end.
    /// See [`Self::connect_to_dai_connector`] for more details.
    pub fn connect_channel_to_dai_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<DaiConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("dai_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DaiServiceMarker {
    type Proxy = DaiServiceProxy;
    type Request = DaiServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.DaiService";
}

/// A request for one of the member protocols of DaiService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum DaiServiceRequest {
    Dai(DaiRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for DaiServiceRequest {
    type Service = DaiServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "dai" => Self::Dai(<DaiRequestStream as fidl::endpoints::RequestStream>::from_channel(
                _channel,
            )),
            _ => panic!("no such member protocol name for service DaiService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["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)
#[cfg(target_os = "fuchsia")]
pub struct DaiServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for DaiServiceProxy {
    type Service = DaiServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl DaiServiceProxy {
    pub fn connect_to_dai(&self) -> Result<DaiProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DaiMarker>();
        self.connect_channel_to_dai(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_dai`, but returns a sync proxy.
    /// See [`Self::connect_to_dai`] for more details.
    pub fn connect_to_dai_sync(&self) -> Result<DaiSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DaiMarker>();
        self.connect_channel_to_dai(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_dai`, but accepts a server end.
    /// See [`Self::connect_to_dai`] for more details.
    pub fn connect_channel_to_dai(
        &self,
        server_end: fidl::endpoints::ServerEnd<DaiMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("dai", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DeviceServiceMarker {
    type Proxy = DeviceServiceProxy;
    type Request = DeviceServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.DeviceService";
}

/// A request for one of the member protocols of DeviceService.
///
#[cfg(target_os = "fuchsia")]
pub enum DeviceServiceRequest {
    Device(CompositeRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for DeviceServiceRequest {
    type Service = DeviceServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <CompositeRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service DeviceService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct DeviceServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for DeviceServiceProxy {
    type Service = DeviceServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl DeviceServiceProxy {
    pub fn connect_to_device(&self) -> Result<CompositeProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CompositeMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(&self) -> Result<CompositeSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CompositeMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<CompositeMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for StreamConfigConnectorInputServiceMarker {
    type Proxy = StreamConfigConnectorInputServiceProxy;
    type Request = StreamConfigConnectorInputServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.StreamConfigConnectorInputService";
}

/// A request for one of the member protocols of StreamConfigConnectorInputService.
///
#[cfg(target_os = "fuchsia")]
pub enum StreamConfigConnectorInputServiceRequest {
    StreamConfigConnector(StreamConfigConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for StreamConfigConnectorInputServiceRequest {
    type Service = StreamConfigConnectorInputServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "stream_config_connector" => Self::StreamConfigConnector(
                <StreamConfigConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service StreamConfigConnectorInputService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["stream_config_connector"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigConnectorInputServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for StreamConfigConnectorInputServiceProxy {
    type Service = StreamConfigConnectorInputServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl StreamConfigConnectorInputServiceProxy {
    pub fn connect_to_stream_config_connector(
        &self,
    ) -> Result<StreamConfigConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_to_stream_config_connector_sync(
        &self,
    ) -> Result<StreamConfigConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but accepts a server end.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_channel_to_stream_config_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<StreamConfigConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("stream_config_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for StreamConfigConnectorOutputServiceMarker {
    type Proxy = StreamConfigConnectorOutputServiceProxy;
    type Request = StreamConfigConnectorOutputServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.StreamConfigConnectorOutputService";
}

/// A request for one of the member protocols of StreamConfigConnectorOutputService.
///
#[cfg(target_os = "fuchsia")]
pub enum StreamConfigConnectorOutputServiceRequest {
    StreamConfigConnector(StreamConfigConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for StreamConfigConnectorOutputServiceRequest {
    type Service = StreamConfigConnectorOutputServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "stream_config_connector" => Self::StreamConfigConnector(
                <StreamConfigConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service StreamConfigConnectorOutputService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["stream_config_connector"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigConnectorOutputServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for StreamConfigConnectorOutputServiceProxy {
    type Service = StreamConfigConnectorOutputServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl StreamConfigConnectorOutputServiceProxy {
    pub fn connect_to_stream_config_connector(
        &self,
    ) -> Result<StreamConfigConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_to_stream_config_connector_sync(
        &self,
    ) -> Result<StreamConfigConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but accepts a server end.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_channel_to_stream_config_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<StreamConfigConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("stream_config_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for StreamConfigConnectorServiceMarker {
    type Proxy = StreamConfigConnectorServiceProxy;
    type Request = StreamConfigConnectorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.StreamConfigConnectorService";
}

/// A request for one of the member protocols of StreamConfigConnectorService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum StreamConfigConnectorServiceRequest {
    StreamConfigConnector(StreamConfigConnectorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for StreamConfigConnectorServiceRequest {
    type Service = StreamConfigConnectorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "stream_config_connector" => Self::StreamConfigConnector(
                <StreamConfigConnectorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service StreamConfigConnectorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["stream_config_connector"]
    }
}
/// # 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)
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigConnectorServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for StreamConfigConnectorServiceProxy {
    type Service = StreamConfigConnectorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl StreamConfigConnectorServiceProxy {
    pub fn connect_to_stream_config_connector(
        &self,
    ) -> Result<StreamConfigConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but returns a sync proxy.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_to_stream_config_connector_sync(
        &self,
    ) -> Result<StreamConfigConnectorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<StreamConfigConnectorMarker>();
        self.connect_channel_to_stream_config_connector(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config_connector`, but accepts a server end.
    /// See [`Self::connect_to_stream_config_connector`] for more details.
    pub fn connect_channel_to_stream_config_connector(
        &self,
        server_end: fidl::endpoints::ServerEnd<StreamConfigConnectorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("stream_config_connector", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for StreamConfigServiceMarker {
    type Proxy = StreamConfigServiceProxy;
    type Request = StreamConfigServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.audio.StreamConfigService";
}

/// A request for one of the member protocols of StreamConfigService.
///
/// # 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)
#[cfg(target_os = "fuchsia")]
pub enum StreamConfigServiceRequest {
    StreamConfig(StreamConfigRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for StreamConfigServiceRequest {
    type Service = StreamConfigServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "stream_config" => Self::StreamConfig(
                <StreamConfigRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service StreamConfigService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["stream_config"]
    }
}
/// # 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)
#[cfg(target_os = "fuchsia")]
pub struct StreamConfigServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for StreamConfigServiceProxy {
    type Service = StreamConfigServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl StreamConfigServiceProxy {
    pub fn connect_to_stream_config(&self) -> Result<StreamConfigProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<StreamConfigMarker>();
        self.connect_channel_to_stream_config(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config`, but returns a sync proxy.
    /// See [`Self::connect_to_stream_config`] for more details.
    pub fn connect_to_stream_config_sync(
        &self,
    ) -> Result<StreamConfigSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<StreamConfigMarker>();
        self.connect_channel_to_stream_config(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_stream_config`, but accepts a server end.
    /// See [`Self::connect_to_stream_config`] for more details.
    pub fn connect_channel_to_stream_config(
        &self,
        server_end: fidl::endpoints::ServerEnd<StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("stream_config", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CodecConnectorConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CodecConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CodecConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::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<fidl::endpoints::ServerEnd<CodecMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CodecConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CodecConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                codec_protocol: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CodecMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CodecMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CompositeConnectorConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::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<fidl::endpoints::ServerEnd<CompositeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CompositeConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CompositeConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                composite_protocol: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.composite_protocol,
                decoder,
                offset + 0,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CompositeCreateRingBufferRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeCreateRingBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeCreateRingBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.processing_element_id),
                    <Format as fidl::encoding::ValueTypeMarker>::borrow(&self.format),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ring_buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<Format, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CompositeCreateRingBufferRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CompositeCreateRingBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                processing_element_id: fidl::new_empty!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                format: fidl::new_empty!(Format, fidl::encoding::DefaultFuchsiaResourceDialect),
                ring_buffer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.processing_element_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Format,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.format,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DaiConnectorConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DaiConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DaiConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::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<fidl::endpoints::ServerEnd<DaiMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DaiConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DaiConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dai_protocol: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DaiMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DaiMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DaiCreateRingBufferRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DaiCreateRingBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DaiCreateRingBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <DaiFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.dai_format),
                    <Format as fidl::encoding::ValueTypeMarker>::borrow(&self.ring_buffer_format),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ring_buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<DaiFormat, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<Format, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DaiCreateRingBufferRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DaiCreateRingBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dai_format: fidl::new_empty!(
                    DaiFormat,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                ring_buffer_format: fidl::new_empty!(
                    Format,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                ring_buffer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dai_format,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Format,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.ring_buffer_format,
                decoder,
                offset + 48,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.ring_buffer,
                decoder,
                offset + 64,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RingBufferGetVmoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RingBufferGetVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RingBufferGetVmoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_frames),
                    <fidl::encoding::HandleType<
                        fidl::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RingBufferGetVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RingBufferGetVmoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                num_frames: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                ring_buffer: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.num_frames,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamConfigConnectorConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamConfigConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StreamConfigConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamConfigMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.protocol),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamConfigMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            StreamConfigConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StreamConfigConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                protocol: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamConfigMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamConfigMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamConfigCreateRingBufferRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamConfigCreateRingBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StreamConfigCreateRingBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Format as fidl::encoding::ValueTypeMarker>::borrow(&self.format),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.ring_buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Format, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            StreamConfigCreateRingBufferRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StreamConfigCreateRingBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                format: fidl::new_empty!(Format, fidl::encoding::DefaultFuchsiaResourceDialect),
                ring_buffer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RingBufferMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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