fidl_fuchsia_media/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCapturerBindGainControlRequest {
    pub gain_control_request:
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCapturerGetReferenceClockResponse {
    pub reference_clock: fidl::Clock,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCapturerSetReferenceClockRequest {
    pub reference_clock: Option<fidl::Clock>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioConsumerBindVolumeControlRequest {
    pub volume_control_request:
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioConsumerCreateStreamSinkRequest {
    pub buffers: Vec<fidl::Vmo>,
    pub stream_type: AudioStreamType,
    pub compression: Option<Box<Compression>>,
    pub stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct AudioCoreBindUsageVolumeControl2Request {
    pub usage: Usage2,
    pub volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCoreBindUsageVolumeControlRequest {
    pub usage: Usage,
    pub volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCoreCreateAudioCapturerRequest {
    pub loopback: bool,
    pub audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct AudioCoreCreateAudioCapturerWithConfigurationRequest {
    pub stream_type: AudioStreamType,
    pub configuration: AudioCapturerConfiguration,
    pub audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCoreCreateAudioRendererRequest {
    pub audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCreateAudioCapturerRequest {
    pub audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    pub loopback: bool,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioCreateAudioRendererRequest {
    pub audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioDeviceEnumeratorAddDeviceByChannelRequest {
    pub device_name: String,
    pub is_input: bool,
    pub channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioRendererBindGainControlRequest {
    pub gain_control_request:
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioRendererGetReferenceClockResponse {
    pub reference_clock: fidl::Clock,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AudioRendererSetReferenceClockRequest {
    pub reference_clock: Option<fidl::Clock>,
}

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

#[derive(Debug, PartialEq, PartialOrd)]
pub struct ProfileProviderRegisterHandlerWithCapacityRequest {
    pub thread_handle: fidl::Thread,
    pub name: String,
    pub period: i64,
    pub capacity: f32,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProfileProviderRegisterMemoryRangeRequest {
    pub vmar_handle: fidl::Vmar,
    pub name: String,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProfileProviderUnregisterHandlerRequest {
    pub thread_handle: fidl::Thread,
    pub name: String,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProfileProviderUnregisterMemoryRangeRequest {
    pub vmar_handle: fidl::Vmar,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionAudioConsumerFactoryCreateAudioConsumerRequest {
    pub session_id: u64,
    pub audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StreamBufferSetAddPayloadBufferRequest {
    pub id: u32,
    pub payload_buffer: fidl::Vmo,
}

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

#[derive(Debug, PartialEq)]
pub struct StreamProcessorSetInputBufferPartialSettingsRequest {
    pub input_settings: StreamBufferPartialSettings,
}

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

#[derive(Debug, PartialEq)]
pub struct StreamProcessorSetOutputBufferPartialSettingsRequest {
    pub output_settings: StreamBufferPartialSettings,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Usage2AudioConsumerFactoryCreateAudioConsumerRequest {
    pub usage: AudioRenderUsage2,
    pub audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UsageAudioConsumerFactoryCreateAudioConsumerRequest {
    pub usage: AudioRenderUsage,
    pub audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct UsageGainReporterRegisterListener2Request {
    pub device_unique_id: String,
    pub usage: Usage2,
    pub usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UsageGainReporterRegisterListenerRequest {
    pub device_unique_id: String,
    pub usage: Usage,
    pub usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct UsageReporterWatch2Request {
    pub usage: Usage2,
    pub usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UsageReporterWatchRequest {
    pub usage: Usage,
    pub usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamBufferPartialSettings {
    /// The containing message starts a new buffer_lifetime_ordinal.
    ///
    /// There is a separate buffer_lifetime_ordinal for input vs. output.
    ///
    /// Re-use of the same value is not allowed.  Values must be odd.  Values
    /// must only increase (increasing by more than 2 is permitted).
    ///
    /// A buffer_lifetime_ordinal lifetime starts at SetInputBufferSettings() or
    /// SetOutputBufferSettings(), and ends at the earlier of
    /// CloseCurrentStream() with release_input_buffers/release_output_buffers
    /// set or SetOutputBufferSettings() with new buffer_lifetime_ordinal in the
    /// case of mid-stream output config change.
    pub buffer_lifetime_ordinal: Option<u64>,
    /// This value indicates which version of constraints the client is/was aware
    /// of so far.
    ///
    /// For input, this must always be 0 because constraints don't change for
    /// input (settings can change, but there's no settings vs current
    /// constraints synchronization issue on input).
    ///
    /// For output, this allows the server to know when the client is
    /// sufficiently caught up before the server will generate any more output.
    ///
    /// When there is no active stream, a client is permitted to re-configure
    /// buffers again using the same buffer_constraints_version_ordinal.
    pub buffer_constraints_version_ordinal: Option<u64>,
    pub single_buffer_mode: Option<bool>,
    pub packet_count_for_server: Option<u32>,
    pub packet_count_for_client: Option<u32>,
    pub sysmem_token:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem::BufferCollectionTokenMarker>>,
    /// The client end of a BufferCollectionToken channel, which the
    /// StreamProcessor will use to deliver constraints to sysmem and learn of
    /// buffers allocated by sysmem.
    ///
    /// The client guarantees that the token is already known to sysmem (via
    /// BufferCollectionToken.Sync(), BufferCollection.Sync(), or
    /// BufferCollectionEvents.OnDuplicatedTokensKnownByServer()).
    pub sysmem2_token:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem2::BufferCollectionTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for ActivityReporterMarker {
    type Proxy = ActivityReporterProxy;
    type RequestStream = ActivityReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ActivityReporterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.ActivityReporter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ActivityReporterMarker {}

pub trait ActivityReporterProxyInterface: Send + Sync {
    type WatchRenderActivityResponseFut: std::future::Future<Output = Result<Vec<AudioRenderUsage>, fidl::Error>>
        + Send;
    fn r#watch_render_activity(&self) -> Self::WatchRenderActivityResponseFut;
    type WatchRenderActivity2ResponseFut: std::future::Future<Output = Result<Vec<AudioRenderUsage2>, fidl::Error>>
        + Send;
    fn r#watch_render_activity2(&self) -> Self::WatchRenderActivity2ResponseFut;
    type WatchCaptureActivityResponseFut: std::future::Future<Output = Result<Vec<AudioCaptureUsage>, fidl::Error>>
        + Send;
    fn r#watch_capture_activity(&self) -> Self::WatchCaptureActivityResponseFut;
    type WatchCaptureActivity2ResponseFut: std::future::Future<Output = Result<Vec<AudioCaptureUsage2>, fidl::Error>>
        + Send;
    fn r#watch_capture_activity2(&self) -> Self::WatchCaptureActivity2ResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ActivityReporterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ActivityReporterSynchronousProxy {
    type Proxy = ActivityReporterProxy;
    type Protocol = ActivityReporterMarker;

    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 ActivityReporterSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ActivityReporterMarker 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<ActivityReporterEvent, fidl::Error> {
        ActivityReporterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_render_activity(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<AudioRenderUsage>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ActivityReporterWatchRenderActivityResponse,
        >(
            (),
            0x2974e9f5880b2f1f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.active_usages)
    }

    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_render_activity2(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<AudioRenderUsage2>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ActivityReporterWatchRenderActivity2Response>,
        >(
            (),
            0x484236fc11b363e6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ActivityReporterMarker>("watch_render_activity2")?;
        Ok(_response.active_usages)
    }

    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_capture_activity(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<AudioCaptureUsage>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ActivityReporterWatchCaptureActivityResponse,
        >(
            (),
            0x70e7038e9658e128,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.active_usages)
    }

    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_capture_activity2(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<AudioCaptureUsage2>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ActivityReporterWatchCaptureActivity2Response>,
        >(
            (),
            0x3d137e0364f9d550,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ActivityReporterMarker>("watch_capture_activity2")?;
        Ok(_response.active_usages)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ActivityReporterProxy {
    type Protocol = ActivityReporterMarker;

    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 ActivityReporterProxy {
    /// Create a new Proxy for fuchsia.media/ActivityReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ActivityReporterMarker 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) -> ActivityReporterEventStream {
        ActivityReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_render_activity(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<AudioRenderUsage>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ActivityReporterProxyInterface::r#watch_render_activity(self)
    }

    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_render_activity2(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<AudioRenderUsage2>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ActivityReporterProxyInterface::r#watch_render_activity2(self)
    }

    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_capture_activity(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<AudioCaptureUsage>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ActivityReporterProxyInterface::r#watch_capture_activity(self)
    }

    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    pub fn r#watch_capture_activity2(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<AudioCaptureUsage2>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ActivityReporterProxyInterface::r#watch_capture_activity2(self)
    }
}

impl ActivityReporterProxyInterface for ActivityReporterProxy {
    type WatchRenderActivityResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioRenderUsage>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_render_activity(&self) -> Self::WatchRenderActivityResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioRenderUsage>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ActivityReporterWatchRenderActivityResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2974e9f5880b2f1f,
            >(_buf?)?;
            Ok(_response.active_usages)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<AudioRenderUsage>>(
            (),
            0x2974e9f5880b2f1f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchRenderActivity2ResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioRenderUsage2>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_render_activity2(&self) -> Self::WatchRenderActivity2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioRenderUsage2>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ActivityReporterWatchRenderActivity2Response>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x484236fc11b363e6,
            >(_buf?)?
            .into_result::<ActivityReporterMarker>("watch_render_activity2")?;
            Ok(_response.active_usages)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<AudioRenderUsage2>>(
            (),
            0x484236fc11b363e6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WatchCaptureActivityResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioCaptureUsage>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_capture_activity(&self) -> Self::WatchCaptureActivityResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioCaptureUsage>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ActivityReporterWatchCaptureActivityResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x70e7038e9658e128,
            >(_buf?)?;
            Ok(_response.active_usages)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<AudioCaptureUsage>>(
            (),
            0x70e7038e9658e128,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchCaptureActivity2ResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioCaptureUsage2>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_capture_activity2(&self) -> Self::WatchCaptureActivity2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioCaptureUsage2>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ActivityReporterWatchCaptureActivity2Response>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3d137e0364f9d550,
            >(_buf?)?
            .into_result::<ActivityReporterMarker>("watch_capture_activity2")?;
            Ok(_response.active_usages)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<AudioCaptureUsage2>>(
            (),
            0x3d137e0364f9d550,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ActivityReporterRequestStream {
    type Protocol = ActivityReporterMarker;
    type ControlHandle = ActivityReporterControlHandle;

    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 {
        ActivityReporterControlHandle { 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 ActivityReporterRequestStream {
    type Item = Result<ActivityReporterRequest, 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 ActivityReporterRequestStream 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 {
                    0x2974e9f5880b2f1f => {
                        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 =
                            ActivityReporterControlHandle { inner: this.inner.clone() };
                        Ok(ActivityReporterRequest::WatchRenderActivity {
                            responder: ActivityReporterWatchRenderActivityResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x484236fc11b363e6 => {
                        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 =
                            ActivityReporterControlHandle { inner: this.inner.clone() };
                        Ok(ActivityReporterRequest::WatchRenderActivity2 {
                            responder: ActivityReporterWatchRenderActivity2Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x70e7038e9658e128 => {
                        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 =
                            ActivityReporterControlHandle { inner: this.inner.clone() };
                        Ok(ActivityReporterRequest::WatchCaptureActivity {
                            responder: ActivityReporterWatchCaptureActivityResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d137e0364f9d550 => {
                        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 =
                            ActivityReporterControlHandle { inner: this.inner.clone() };
                        Ok(ActivityReporterRequest::WatchCaptureActivity2 {
                            responder: ActivityReporterWatchCaptureActivity2Responder {
                                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(ActivityReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ActivityReporterControlHandle {
                                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(ActivityReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ActivityReporterControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ActivityReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol for monitoring the usage activity of the AudioRenderers and AudioCapturers.
#[derive(Debug)]
pub enum ActivityReporterRequest {
    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    WatchRenderActivity { responder: ActivityReporterWatchRenderActivityResponder },
    /// Notifies the client whenever there is a change in the set of active AudioRenderUsages.
    /// It returns immediately the first time that it is called.
    WatchRenderActivity2 { responder: ActivityReporterWatchRenderActivity2Responder },
    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    WatchCaptureActivity { responder: ActivityReporterWatchCaptureActivityResponder },
    /// Notifies the client whenever there is a change in the set of active AudioCaptureUsages.
    /// It returns immediately the first time that it is called.
    WatchCaptureActivity2 { responder: ActivityReporterWatchCaptureActivity2Responder },
    /// 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: ActivityReporterControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ActivityReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_render_activity(
        self,
    ) -> Option<(ActivityReporterWatchRenderActivityResponder)> {
        if let ActivityReporterRequest::WatchRenderActivity { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_render_activity2(
        self,
    ) -> Option<(ActivityReporterWatchRenderActivity2Responder)> {
        if let ActivityReporterRequest::WatchRenderActivity2 { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_capture_activity(
        self,
    ) -> Option<(ActivityReporterWatchCaptureActivityResponder)> {
        if let ActivityReporterRequest::WatchCaptureActivity { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_capture_activity2(
        self,
    ) -> Option<(ActivityReporterWatchCaptureActivity2Responder)> {
        if let ActivityReporterRequest::WatchCaptureActivity2 { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ActivityReporterRequest::WatchRenderActivity { .. } => "watch_render_activity",
            ActivityReporterRequest::WatchRenderActivity2 { .. } => "watch_render_activity2",
            ActivityReporterRequest::WatchCaptureActivity { .. } => "watch_capture_activity",
            ActivityReporterRequest::WatchCaptureActivity2 { .. } => "watch_capture_activity2",
            ActivityReporterRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            ActivityReporterRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ActivityReporterControlHandle {
    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 ActivityReporterControlHandle {}

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

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

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

    fn send_raw(&self, mut active_usages: &[AudioRenderUsage]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ActivityReporterWatchRenderActivityResponse>(
            (active_usages,),
            self.tx_id,
            0x2974e9f5880b2f1f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut active_usages: &[AudioRenderUsage2]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            ActivityReporterWatchRenderActivity2Response,
        >>(
            fidl::encoding::Flexible::new((active_usages,)),
            self.tx_id,
            0x484236fc11b363e6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut active_usages: &[AudioCaptureUsage]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ActivityReporterWatchCaptureActivityResponse>(
            (active_usages,),
            self.tx_id,
            0x70e7038e9658e128,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut active_usages: &[AudioCaptureUsage2]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            ActivityReporterWatchCaptureActivity2Response,
        >>(
            fidl::encoding::Flexible::new((active_usages,)),
            self.tx_id,
            0x3d137e0364f9d550,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for AudioMarker {
    type Proxy = AudioProxy;
    type RequestStream = AudioRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.Audio";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioMarker {}

pub trait AudioProxyInterface: Send + Sync {
    fn r#create_audio_renderer(
        &self,
        audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer(
        &self,
        audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        loopback: bool,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioSynchronousProxy {
    type Proxy = AudioProxy;
    type Protocol = AudioMarker;

    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 AudioSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioMarker 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<AudioEvent, fidl::Error> {
        AudioEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#create_audio_renderer(
        &self,
        mut audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCreateAudioRendererRequest>(
            (audio_renderer_request,),
            0x572f413566fd58f1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    pub fn r#create_audio_capturer(
        &self,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        mut loopback: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCreateAudioCapturerRequest>(
            (audio_capturer_request, loopback),
            0x44660fc63a6202f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioProxy {
    type Protocol = AudioMarker;

    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 AudioProxy {
    /// Create a new Proxy for fuchsia.media/Audio.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioMarker 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) -> AudioEventStream {
        AudioEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#create_audio_renderer(
        &self,
        mut audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        AudioProxyInterface::r#create_audio_renderer(self, audio_renderer_request)
    }

    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    pub fn r#create_audio_capturer(
        &self,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        mut loopback: bool,
    ) -> Result<(), fidl::Error> {
        AudioProxyInterface::r#create_audio_capturer(self, audio_capturer_request, loopback)
    }
}

impl AudioProxyInterface for AudioProxy {
    fn r#create_audio_renderer(
        &self,
        mut audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCreateAudioRendererRequest>(
            (audio_renderer_request,),
            0x572f413566fd58f1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_audio_capturer(
        &self,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        mut loopback: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCreateAudioCapturerRequest>(
            (audio_capturer_request, loopback),
            0x44660fc63a6202f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AudioRequestStream {
    type Protocol = AudioMarker;
    type ControlHandle = AudioControlHandle;

    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 {
        AudioControlHandle { 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 AudioRequestStream {
    type Item = Result<AudioRequest, 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 AudioRequestStream 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 {
                    0x572f413566fd58f1 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCreateAudioRendererRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCreateAudioRendererRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::CreateAudioRenderer {
                            audio_renderer_request: req.audio_renderer_request,

                            control_handle,
                        })
                    }
                    0x44660fc63a6202f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCreateAudioCapturerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCreateAudioCapturerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioControlHandle { inner: this.inner.clone() };
                        Ok(AudioRequest::CreateAudioCapturer {
                            audio_capturer_request: req.audio_capturer_request,
                            loopback: req.loopback,

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

#[derive(Debug)]
pub enum AudioRequest {
    CreateAudioRenderer {
        audio_renderer_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
        control_handle: AudioControlHandle,
    },
    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    CreateAudioCapturer {
        audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        loopback: bool,
        control_handle: AudioControlHandle,
    },
}

impl AudioRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_renderer(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<AudioRendererMarker>, AudioControlHandle)> {
        if let AudioRequest::CreateAudioRenderer { audio_renderer_request, control_handle } = self {
            Some((audio_renderer_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_capturer(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<AudioCapturerMarker>, bool, AudioControlHandle)> {
        if let AudioRequest::CreateAudioCapturer {
            audio_capturer_request,
            loopback,
            control_handle,
        } = self
        {
            Some((audio_capturer_request, loopback, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioRequest::CreateAudioRenderer { .. } => "create_audio_renderer",
            AudioRequest::CreateAudioCapturer { .. } => "create_audio_capturer",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioControlHandle {
    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 AudioControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for AudioCapturerMarker {
    type Proxy = AudioCapturerProxy;
    type RequestStream = AudioCapturerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioCapturerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.AudioCapturer";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioCapturerMarker {}

pub trait AudioCapturerProxyInterface: Send + Sync {
    fn r#add_payload_buffer(&self, id: u32, payload_buffer: fidl::Vmo) -> Result<(), fidl::Error>;
    fn r#remove_payload_buffer(&self, id: u32) -> Result<(), fidl::Error>;
    fn r#release_packet(&self, packet: &StreamPacket) -> Result<(), fidl::Error>;
    type DiscardAllPacketsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut;
    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error>;
    fn r#set_pcm_stream_type(&self, stream_type: &AudioStreamType) -> Result<(), fidl::Error>;
    type CaptureAtResponseFut: std::future::Future<Output = Result<StreamPacket, fidl::Error>>
        + Send;
    fn r#capture_at(
        &self,
        payload_buffer_id: u32,
        payload_offset: u32,
        frames: u32,
    ) -> Self::CaptureAtResponseFut;
    fn r#start_async_capture(&self, frames_per_packet: u32) -> Result<(), fidl::Error>;
    type StopAsyncCaptureResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#stop_async_capture(&self) -> Self::StopAsyncCaptureResponseFut;
    fn r#stop_async_capture_no_reply(&self) -> Result<(), fidl::Error>;
    fn r#bind_gain_control(
        &self,
        gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type GetReferenceClockResponseFut: std::future::Future<Output = Result<fidl::Clock, fidl::Error>>
        + Send;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut;
    fn r#set_reference_clock(
        &self,
        reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error>;
    fn r#set_usage(&self, usage: AudioCaptureUsage) -> Result<(), fidl::Error>;
    fn r#set_usage2(&self, usage: AudioCaptureUsage2) -> Result<(), fidl::Error>;
    type GetStreamTypeResponseFut: std::future::Future<Output = Result<StreamType, fidl::Error>>
        + Send;
    fn r#get_stream_type(&self) -> Self::GetStreamTypeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioCapturerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioCapturerSynchronousProxy {
    type Proxy = AudioCapturerProxy;
    type Protocol = AudioCapturerMarker;

    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 AudioCapturerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioCapturerMarker 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<AudioCapturerEvent, fidl::Error> {
        AudioCapturerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    pub fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSourceReleasePacketRequest>(
            (packet,),
            0x7a7b57f0f7d9e4bb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#discard_all_packets(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x27afd605e97b09d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35f9d721e905b831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the stream type of the stream to be delivered. Causes the source
    /// material to be reformatted/resampled if needed in order to produce the
    /// requested stream type. Must be called before the payload buffer is
    /// established.
    pub fn r#set_pcm_stream_type(
        &self,
        mut stream_type: &AudioStreamType,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetPcmStreamTypeRequest>(
            (stream_type,),
            0x1531ea9ea2c852cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Explicitly specifies a region of the shared payload buffer for the audio
    /// input to capture into.
    pub fn r#capture_at(
        &self,
        mut payload_buffer_id: u32,
        mut payload_offset: u32,
        mut frames: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamPacket, fidl::Error> {
        let _response = self
            .client
            .send_query::<AudioCapturerCaptureAtRequest, AudioCapturerCaptureAtResponse>(
                (payload_buffer_id, payload_offset, frames),
                0x784e25df72cea780,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.captured_packet)
    }

    /// Places the AudioCapturer into 'async' capture mode and begin to produce
    /// packets of exactly 'frames_per_packet' number of frames each. The
    /// OnPacketProduced event (of StreamSink) will be used to inform the client
    /// of produced packets.
    pub fn r#start_async_capture(&self, mut frames_per_packet: u32) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerStartAsyncCaptureRequest>(
            (frames_per_packet,),
            0x7768adbb1ccfd7a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops capturing in 'async' capture mode and (optionally) deliver a callback
    /// that may be used by the client if explicit synchronization is needed.
    pub fn r#stop_async_capture(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x5bfc8790a8cef8cb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#stop_async_capture_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x33223cb2962c95e3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to the gain control for this AudioCapturer.
    pub fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerBindGainControlRequest>(
            (gain_control_request,),
            0x658a6a17ddb3a8e0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    pub fn r#get_reference_clock(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Clock, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioCapturerGetReferenceClockResponse>(
                (),
                0x50d037aa5a4b4d71,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.reference_clock)
    }

    /// Sets the reference clock that controls this capturer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called after the capturer payload buffer has been
    /// added. It also cannot be called a second time (even before capture).
    /// If the client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    pub fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetReferenceClockRequest>(
            (reference_clock,),
            0x732b2c496d521bcf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the usage of the capture stream. This may be changed on the fly, but packets in flight
    /// may be affected. By default, Capturers are created with the FOREGROUND usage.
    pub fn r#set_usage(&self, mut usage: AudioCaptureUsage) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetUsageRequest>(
            (usage,),
            0x42a16f392bd21b25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the usage of the capture stream. This may be changed on the fly, but this may affect
    /// packets in flight. By default, Capturers are created with the FOREGROUND usage.
    pub fn r#set_usage2(&self, mut usage: AudioCaptureUsage2) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetUsage2Request>(
            (usage,),
            0x7a73e251b8d2382b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Gets the currently configured stream type. Note: for an AudioCapturer
    /// which was just created and has not yet had its stream type explicitly
    /// set, this will retrieve the stream type -- at the time the AudioCapturer
    /// was created -- of the source (input or looped-back output) to which the
    /// AudioCapturer is bound. Even if this matches the client's desired format,
    /// `SetPcmStreamType` must still be called.
    pub fn r#get_stream_type(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamType, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioCapturerGetStreamTypeResponse>(
                (),
                0x5dcaaa670b433088,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.stream_type)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioCapturerProxy {
    type Protocol = AudioCapturerMarker;

    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 AudioCapturerProxy {
    /// Create a new Proxy for fuchsia.media/AudioCapturer.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioCapturerMarker 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) -> AudioCapturerEventStream {
        AudioCapturerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#add_payload_buffer(self, id, payload_buffer)
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#remove_payload_buffer(self, id)
    }

    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    pub fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#release_packet(self, packet)
    }

    pub fn r#discard_all_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCapturerProxyInterface::r#discard_all_packets(self)
    }

    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#discard_all_packets_no_reply(self)
    }

    /// Sets the stream type of the stream to be delivered. Causes the source
    /// material to be reformatted/resampled if needed in order to produce the
    /// requested stream type. Must be called before the payload buffer is
    /// established.
    pub fn r#set_pcm_stream_type(
        &self,
        mut stream_type: &AudioStreamType,
    ) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#set_pcm_stream_type(self, stream_type)
    }

    /// Explicitly specifies a region of the shared payload buffer for the audio
    /// input to capture into.
    pub fn r#capture_at(
        &self,
        mut payload_buffer_id: u32,
        mut payload_offset: u32,
        mut frames: u32,
    ) -> fidl::client::QueryResponseFut<StreamPacket, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioCapturerProxyInterface::r#capture_at(self, payload_buffer_id, payload_offset, frames)
    }

    /// Places the AudioCapturer into 'async' capture mode and begin to produce
    /// packets of exactly 'frames_per_packet' number of frames each. The
    /// OnPacketProduced event (of StreamSink) will be used to inform the client
    /// of produced packets.
    pub fn r#start_async_capture(&self, mut frames_per_packet: u32) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#start_async_capture(self, frames_per_packet)
    }

    /// Stops capturing in 'async' capture mode and (optionally) deliver a callback
    /// that may be used by the client if explicit synchronization is needed.
    pub fn r#stop_async_capture(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCapturerProxyInterface::r#stop_async_capture(self)
    }

    pub fn r#stop_async_capture_no_reply(&self) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#stop_async_capture_no_reply(self)
    }

    /// Binds to the gain control for this AudioCapturer.
    pub fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#bind_gain_control(self, gain_control_request)
    }

    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    pub fn r#get_reference_clock(
        &self,
    ) -> fidl::client::QueryResponseFut<fidl::Clock, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioCapturerProxyInterface::r#get_reference_clock(self)
    }

    /// Sets the reference clock that controls this capturer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called after the capturer payload buffer has been
    /// added. It also cannot be called a second time (even before capture).
    /// If the client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    pub fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#set_reference_clock(self, reference_clock)
    }

    /// Sets the usage of the capture stream. This may be changed on the fly, but packets in flight
    /// may be affected. By default, Capturers are created with the FOREGROUND usage.
    pub fn r#set_usage(&self, mut usage: AudioCaptureUsage) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#set_usage(self, usage)
    }

    /// Sets the usage of the capture stream. This may be changed on the fly, but this may affect
    /// packets in flight. By default, Capturers are created with the FOREGROUND usage.
    pub fn r#set_usage2(&self, mut usage: AudioCaptureUsage2) -> Result<(), fidl::Error> {
        AudioCapturerProxyInterface::r#set_usage2(self, usage)
    }

    /// Gets the currently configured stream type. Note: for an AudioCapturer
    /// which was just created and has not yet had its stream type explicitly
    /// set, this will retrieve the stream type -- at the time the AudioCapturer
    /// was created -- of the source (input or looped-back output) to which the
    /// AudioCapturer is bound. Even if this matches the client's desired format,
    /// `SetPcmStreamType` must still be called.
    pub fn r#get_stream_type(
        &self,
    ) -> fidl::client::QueryResponseFut<StreamType, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioCapturerProxyInterface::r#get_stream_type(self)
    }
}

impl AudioCapturerProxyInterface for AudioCapturerProxy {
    fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSourceReleasePacketRequest>(
            (packet,),
            0x7a7b57f0f7d9e4bb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35f9d721e905b831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_pcm_stream_type(&self, mut stream_type: &AudioStreamType) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetPcmStreamTypeRequest>(
            (stream_type,),
            0x1531ea9ea2c852cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CaptureAtResponseFut =
        fidl::client::QueryResponseFut<StreamPacket, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#capture_at(
        &self,
        mut payload_buffer_id: u32,
        mut payload_offset: u32,
        mut frames: u32,
    ) -> Self::CaptureAtResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamPacket, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCapturerCaptureAtResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x784e25df72cea780,
            >(_buf?)?;
            Ok(_response.captured_packet)
        }
        self.client.send_query_and_decode::<AudioCapturerCaptureAtRequest, StreamPacket>(
            (payload_buffer_id, payload_offset, frames),
            0x784e25df72cea780,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#start_async_capture(&self, mut frames_per_packet: u32) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerStartAsyncCaptureRequest>(
            (frames_per_packet,),
            0x7768adbb1ccfd7a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#stop_async_capture_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x33223cb2962c95e3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerBindGainControlRequest>(
            (gain_control_request,),
            0x658a6a17ddb3a8e0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetReferenceClockResponseFut =
        fidl::client::QueryResponseFut<fidl::Clock, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Clock, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCapturerGetReferenceClockResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50d037aa5a4b4d71,
            >(_buf?)?;
            Ok(_response.reference_clock)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fidl::Clock>(
            (),
            0x50d037aa5a4b4d71,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetReferenceClockRequest>(
            (reference_clock,),
            0x732b2c496d521bcf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_usage(&self, mut usage: AudioCaptureUsage) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetUsageRequest>(
            (usage,),
            0x42a16f392bd21b25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_usage2(&self, mut usage: AudioCaptureUsage2) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerSetUsage2Request>(
            (usage,),
            0x7a73e251b8d2382b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type GetStreamTypeResponseFut =
        fidl::client::QueryResponseFut<StreamType, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_stream_type(&self) -> Self::GetStreamTypeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamType, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCapturerGetStreamTypeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5dcaaa670b433088,
            >(_buf?)?;
            Ok(_response.stream_type)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, StreamType>(
            (),
            0x5dcaaa670b433088,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl AudioCapturerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_packet_produced(self) -> Option<StreamPacket> {
        if let AudioCapturerEvent::OnPacketProduced { packet } = self {
            Some((packet))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_end_of_stream(self) -> Option<()> {
        if let AudioCapturerEvent::OnEndOfStream {} = self { Some(()) } else { None }
    }

    /// Decodes a message buffer as a [`AudioCapturerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AudioCapturerEvent, 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 {
            0x6bbe69746a3c8bd9 => {
                let mut out = fidl::new_empty!(
                    StreamSourceOnPacketProducedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSourceOnPacketProducedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioCapturerEvent::OnPacketProduced { packet: out.packet }))
            }
            0x550e69b41d03e2c2 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioCapturerEvent::OnEndOfStream {}))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(AudioCapturerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <AudioCapturerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for AudioCapturerRequestStream {
    type Protocol = AudioCapturerMarker;
    type ControlHandle = AudioCapturerControlHandle;

    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 {
        AudioCapturerControlHandle { 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 AudioCapturerRequestStream {
    type Item = Result<AudioCapturerRequest, 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 AudioCapturerRequestStream 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 {
                    0x3b3a37fc34fe5b56 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetAddPayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetAddPayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::AddPayloadBuffer {
                            id: req.id,
                            payload_buffer: req.payload_buffer,

                            control_handle,
                        })
                    }
                    0x5d1e4f74c3658262 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetRemovePayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetRemovePayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::RemovePayloadBuffer { id: req.id, control_handle })
                    }
                    0x7a7b57f0f7d9e4bb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSourceReleasePacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSourceReleasePacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::ReleasePacket {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x27afd605e97b09d2 => {
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::DiscardAllPackets {
                            responder: AudioCapturerDiscardAllPacketsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35f9d721e905b831 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    0x1531ea9ea2c852cd => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerSetPcmStreamTypeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerSetPcmStreamTypeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::SetPcmStreamType {
                            stream_type: req.stream_type,

                            control_handle,
                        })
                    }
                    0x784e25df72cea780 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerCaptureAtRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerCaptureAtRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::CaptureAt {
                            payload_buffer_id: req.payload_buffer_id,
                            payload_offset: req.payload_offset,
                            frames: req.frames,

                            responder: AudioCapturerCaptureAtResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7768adbb1ccfd7a6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerStartAsyncCaptureRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerStartAsyncCaptureRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::StartAsyncCapture {
                            frames_per_packet: req.frames_per_packet,

                            control_handle,
                        })
                    }
                    0x5bfc8790a8cef8cb => {
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::StopAsyncCapture {
                            responder: AudioCapturerStopAsyncCaptureResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x33223cb2962c95e3 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::StopAsyncCaptureNoReply { control_handle })
                    }
                    0x658a6a17ddb3a8e0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerBindGainControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerBindGainControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::BindGainControl {
                            gain_control_request: req.gain_control_request,

                            control_handle,
                        })
                    }
                    0x50d037aa5a4b4d71 => {
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::GetReferenceClock {
                            responder: AudioCapturerGetReferenceClockResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x732b2c496d521bcf => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerSetReferenceClockRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerSetReferenceClockRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::SetReferenceClock {
                            reference_clock: req.reference_clock,

                            control_handle,
                        })
                    }
                    0x42a16f392bd21b25 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerSetUsageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerSetUsageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::SetUsage { usage: req.usage, control_handle })
                    }
                    0x7a73e251b8d2382b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCapturerSetUsage2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCapturerSetUsage2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::SetUsage2 { usage: req.usage, control_handle })
                    }
                    0x5dcaaa670b433088 => {
                        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 =
                            AudioCapturerControlHandle { inner: this.inner.clone() };
                        Ok(AudioCapturerRequest::GetStreamType {
                            responder: AudioCapturerGetStreamTypeResponder {
                                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(AudioCapturerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioCapturerControlHandle {
                                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(AudioCapturerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioCapturerControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AudioCapturerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// AudioCapturer
///
/// An AudioCapturer is an interface returned from an fuchsia.media.Audio's
/// CreateAudioCapturer method, which may be used by clients to capture audio
/// from either the current default audio input device, or the current default
/// audio output device depending on the flags passed during creation.
///
/// **Format support**
///
/// See (Get|Set)StreamType below. By default, the captured stream type will be
/// initially determined by the currently configured stream type of the source
/// that the AudioCapturer was bound to at creation time. Users may either fetch
/// this type using GetStreamType, or they may choose to have the media
/// resampled or converted to a type of their choosing by calling SetStreamType.
/// Note: the stream type may only be set while the system is not running,
/// meaning that there are no pending capture regions (specified using CaptureAt)
/// and that the system is not currently running in 'async' capture mode.
///
/// **Buffers and memory management**
///
/// Audio data is captured into a shared memory buffer (a VMO) supplied by the
/// user to the AudioCapturer during the AddPayloadBuffer call. Please note the
/// following requirements related to the management of the payload buffer.
///
/// + The payload buffer must be supplied before any capture operation may
///   start. Any attempt to start capture (via either CaptureAt or
///   StartAsyncCapture) before a payload buffer has been established is an
///   error.
/// + The payload buffer may not be changed while there are any capture
///   operations pending.
/// + The stream type may not be changed after the payload buffer has been set.
/// + The payload buffer must be an integral number of audio frame sizes (in
///   bytes)
/// + When running in 'async' mode (see below), the payload buffer must be at
///   least as large as twice the frames_per_packet size specified during
///   StartAsyncCapture.
/// + The handle to the payload buffer supplied by the user must be readable,
///   writable, mappable and transferable.
/// + Users should always treat the payload buffer as read-only.
///
/// **Synchronous vs. Asynchronous capture mode**
///
/// The AudioCapturer interface can be used in one of two mutually exclusive
/// modes: Synchronous and Asynchronous. A description of each mode and their
/// tradeoffs is given below.
///
/// **Synchronous mode**
///
/// By default, AudioCapturer instances are running in 'sync' mode. They will
/// only capture data when a user supplies at least one region to capture into
/// using the CaptureAt method. Regions supplied in this way will be filled in
/// the order that they are received and returned to the client as StreamPackets
/// via the return value of the CaptureAt method. If an AudioCapturer instance
/// has data to capture, but no place to put it (because there are no more
/// pending regions to fill), the next payload generated will indicate that their
/// has been an overflow by setting the Discontinuity flag on the next produced
/// StreamPacket. Synchronous mode may not be used in conjunction with
/// Asynchronous mode. It is an error to attempt to call StartAsyncCapture while
/// the system still regions supplied by CaptureAt waiting to be filled.
///
/// If a user has supplied regions to be filled by the AudioCapturer instance in
/// the past, but wishes to reclaim those regions, they may do so using the
/// DiscardAllPackets method. Calling the DiscardAllPackets method will cause
/// all pending regions to be returned, but with `NO_TIMESTAMP` as their
/// StreamPacket's PTS. See "Timing and Overflows", below, for a discussion of
/// timestamps and discontinuity flags. After a DiscardAllPackets operation,
/// an OnEndOfStream event will be produced. While an AudioCapturer will never
/// overwrite any region of the payload buffer after a completed region is
/// returned, it may overwrite the unfilled portions of a partially filled
/// buffer which has been returned as a result of a DiscardAllPackets operation.
///
/// **Asynchronous mode**
///
/// While running in 'async' mode, clients do not need to explicitly supply
/// shared buffer regions to be filled by the AudioCapturer instance. Instead, a
/// client enters into 'async' mode by calling StartAsyncCapture and supplying a
/// callback interface and the number of frames to capture per-callback. Once
/// running in async mode, the AudioCapturer instance will identify which
/// payload buffer regions to capture into, capture the specified number of
/// frames, then deliver those frames as StreamPackets using the OnPacketCapture
/// FIDL event. Users may stop capturing and return the AudioCapturer instance to
/// 'sync' mode using the StopAsyncCapture method.
///
/// It is considered an error to attempt any of the following operations.
///
/// + To attempt to enter 'async' capture mode when no payload buffer has been
///   established.
/// + To specify a number of frames to capture per payload which does not permit
///   at least two contiguous capture payloads to exist in the established
///   shared payload buffer simultaneously.
/// + To send a region to capture into using the CaptureAt method while the
///   AudioCapturer instance is running in 'async' mode.
/// + To attempt to call DiscardAllPackets while the AudioCapturer instance is
///   running in 'async' mode.
/// + To attempt to re-start 'async' mode capturing without having first
///   stopped.
/// + To attempt any operation except for SetGain while in the process of
///   stopping.
///
/// **Synchronizing with a StopAsyncCapture operation**
///
/// Stopping asynchronous capture mode and returning to synchronous capture mode
/// is an operation which takes time. Aside from SetGain, users may not call any
/// other methods on the AudioCapturer interface after calling StopAsyncCapture
/// (including calling StopAsyncCapture again) until after the stop operation has
/// completed. Because of this, it is important for users to be able to
/// synchronize with the stop operation. Two mechanisms are provided for doing
/// so.
///
/// The first is to use StopAsyncCapture (not the NoReply variant). When the user's
/// callback has been called, they can be certain that stop operation is complete
/// and that the AudioCapturer instance has returned to synchronous operation
/// mode.
///
/// The second way to determine that a stop operation has completed is to use the
/// flags on the packets which get delivered via the user-supplied
/// AudioCapturerCallback interface after calling StopAsyncCapture. When
/// asked to stop, any partially filled packet will be returned to the user, and
/// the final packet returned will always have the end-of-stream flag (kFlagsEos)
/// set on it to indicate that this is the final frame in the sequence. If
/// there is no partially filled packet to return, the AudioCapturer will
/// synthesize an empty packet with no timestamp, and offset/length set to zero,
/// in order to deliver a packet with the end-of-stream flag set on it. Once
/// users have seen the end-of-stream flag after calling stop, the AudioCapturer
/// has finished the stop operation and returned to synchronous operating mode.
///
/// **Timing and Overflows**
///
/// All media packets produced by an AudioCapturer instance will have their PTS
/// field filled out with the capture time of the audio expressed as a timestamp
/// given by the reference clock timeline. Note: this timestamp is actually a
/// capture timestamp, not a presentation timestamp (it is more of a CTS than a
/// PTS) and is meant to represent the underlying system's best estimate of the
/// capture time of the first frame of audio, including all outboard and hardware
/// introduced buffering delay. As a result, all timestamps produced by an
/// AudioCapturer should be expected to be in the past relative to 'now' on the
/// stream's reference clock timeline.
///
/// The one exception to the "everything has an explicit timestamp" rule is when
/// discarding submitted regions while operating in synchronous mode. Discarded
/// packets have no data in them, but FIDL demands that all pending
/// method-return-value callbacks be executed. Because of this, the regions will
/// be returned to the user, but their timestamps will be set to
/// `NO_TIMESTAMP`, and their payload sizes will be set to zero. Any
/// partially filled payload will have a valid timestamp, but a payload size
/// smaller than originally requested. The final discarded payload (if there
/// were any to discard) will be followed by an OnEndOfStream event.
///
/// Two StreamPackets delivered by an AudioCapturer instance are 'continuous' if
/// the first frame of audio contained in the second packet was captured exactly
/// one nominal frame time after the final frame of audio in the first packet.
/// If this relationship does not hold, the second StreamPacket will have the
/// `STREAM_PACKET_FLAG_DISCONTINUITY` bit set in its `flags` field.
///
/// Even though explicit timestamps are provided on every StreamPacket produced,
/// users who have very precise timing requirements are encouraged to always
/// reason about time by counting frames delivered since the last discontinuity,
/// rather than simply using the raw capture timestamps. This is because the
/// explicit timestamps written on continuous packets may have a small amount of
/// rounding error based on whether or not the units of the capture timeline
/// reference clock are divisible by the chosen audio frame rate.
///
/// Users should always expect the first StreamPacket produced by an
/// AudioCapturer to have the discontinuous flag set on it (as there is no
/// previous packet to be continuous with). Similarly, the first StreamPacket
/// after a DiscardAllPackets or a Stop/Start cycle will always be
/// discontinuous. After that, there are only two reasons that a StreamPacket
/// will ever be discontinuous:
///
/// 1. The user is operating in synchronous mode and does not supply regions to
///    be filled quickly enough. If the next continuous frame of data has not
///    been captured by the time it needs to be purged from the source buffers,
///    an overflow has occurred and the AudioCapturer will flag the next captured
///    region as discontinuous.
/// 2. The user is operating in asynchronous mode and some internal error
///    prevents the AudioCapturer instance from capturing the next frame of audio
///    in a continuous fashion. This might be high system load or a hardware
///    error, but in general it is something which should never normally happen.
///    In practice, however, if it does, the next produced packet will be flagged
///    as being discontinuous.
///
/// **Synchronous vs. Asynchronous Trade-offs**
///
/// The choice of operating in synchronous vs. asynchronous mode is up to the
/// user, and depending on the user's requirements, there are some advantages and
/// disadvantages to each choice.
///
/// Synchronous mode requires only a single Zircon channel under the hood and can
/// achieve some small savings because of this. In addition, the user has
/// complete control over the buffer management. Users specify exactly where
/// audio will be captured to and in what order. Because of this, if users do
/// not need to always be capturing, it is simple to stop and restart the capture
/// later (just by ceasing to supply packets, then resuming later on). Payloads
/// do not need to be uniform in size either, clients may specify payloads of
/// whatever granularity is appropriate.
///
/// The primary downside of operating in synchronous mode is that two messages
/// will need to be sent for every packet to be captured. One to inform the
/// AudioCapturer of the instance to capture into, and one to inform the user
/// that the packet has been captured. This may end up increasing overhead and
/// potentially complicating client designs.
///
/// Asynchronous mode has the advantage requiring only 1/2 of the messages,
/// however, when operating in 'async' mode, AudioCapturer instances have no way
/// of knowing if a user is processing the StreamPackets being sent in a timely
/// fashion, and no way of automatically detecting an overflow condition. Users
/// of 'async' mode should be careful to use a buffer large enough to ensure that
/// they will be able to process their data before an AudioCapturer will be
/// forced to overwrite it.
#[derive(Debug)]
pub enum AudioCapturerRequest {
    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    AddPayloadBuffer {
        id: u32,
        payload_buffer: fidl::Vmo,
        control_handle: AudioCapturerControlHandle,
    },
    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    RemovePayloadBuffer {
        id: u32,
        control_handle: AudioCapturerControlHandle,
    },
    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    ReleasePacket {
        packet: StreamPacket,
        control_handle: AudioCapturerControlHandle,
    },
    DiscardAllPackets {
        responder: AudioCapturerDiscardAllPacketsResponder,
    },
    DiscardAllPacketsNoReply {
        control_handle: AudioCapturerControlHandle,
    },
    /// Sets the stream type of the stream to be delivered. Causes the source
    /// material to be reformatted/resampled if needed in order to produce the
    /// requested stream type. Must be called before the payload buffer is
    /// established.
    SetPcmStreamType {
        stream_type: AudioStreamType,
        control_handle: AudioCapturerControlHandle,
    },
    /// Explicitly specifies a region of the shared payload buffer for the audio
    /// input to capture into.
    CaptureAt {
        payload_buffer_id: u32,
        payload_offset: u32,
        frames: u32,
        responder: AudioCapturerCaptureAtResponder,
    },
    /// Places the AudioCapturer into 'async' capture mode and begin to produce
    /// packets of exactly 'frames_per_packet' number of frames each. The
    /// OnPacketProduced event (of StreamSink) will be used to inform the client
    /// of produced packets.
    StartAsyncCapture {
        frames_per_packet: u32,
        control_handle: AudioCapturerControlHandle,
    },
    /// Stops capturing in 'async' capture mode and (optionally) deliver a callback
    /// that may be used by the client if explicit synchronization is needed.
    StopAsyncCapture {
        responder: AudioCapturerStopAsyncCaptureResponder,
    },
    StopAsyncCaptureNoReply {
        control_handle: AudioCapturerControlHandle,
    },
    /// Binds to the gain control for this AudioCapturer.
    BindGainControl {
        gain_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
        control_handle: AudioCapturerControlHandle,
    },
    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    GetReferenceClock {
        responder: AudioCapturerGetReferenceClockResponder,
    },
    /// Sets the reference clock that controls this capturer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called after the capturer payload buffer has been
    /// added. It also cannot be called a second time (even before capture).
    /// If the client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    SetReferenceClock {
        reference_clock: Option<fidl::Clock>,
        control_handle: AudioCapturerControlHandle,
    },
    /// Sets the usage of the capture stream. This may be changed on the fly, but packets in flight
    /// may be affected. By default, Capturers are created with the FOREGROUND usage.
    SetUsage {
        usage: AudioCaptureUsage,
        control_handle: AudioCapturerControlHandle,
    },
    /// Sets the usage of the capture stream. This may be changed on the fly, but this may affect
    /// packets in flight. By default, Capturers are created with the FOREGROUND usage.
    SetUsage2 {
        usage: AudioCaptureUsage2,
        control_handle: AudioCapturerControlHandle,
    },
    /// Gets the currently configured stream type. Note: for an AudioCapturer
    /// which was just created and has not yet had its stream type explicitly
    /// set, this will retrieve the stream type -- at the time the AudioCapturer
    /// was created -- of the source (input or looped-back output) to which the
    /// AudioCapturer is bound. Even if this matches the client's desired format,
    /// `SetPcmStreamType` must still be called.
    GetStreamType {
        responder: AudioCapturerGetStreamTypeResponder,
    },
    /// 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: AudioCapturerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl AudioCapturerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_payload_buffer(self) -> Option<(u32, fidl::Vmo, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::AddPayloadBuffer { id, payload_buffer, control_handle } = self
        {
            Some((id, payload_buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_payload_buffer(self) -> Option<(u32, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::RemovePayloadBuffer { id, control_handle } = self {
            Some((id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_packet(self) -> Option<(StreamPacket, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::ReleasePacket { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets(self) -> Option<(AudioCapturerDiscardAllPacketsResponder)> {
        if let AudioCapturerRequest::DiscardAllPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets_no_reply(self) -> Option<(AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::DiscardAllPacketsNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pcm_stream_type(self) -> Option<(AudioStreamType, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::SetPcmStreamType { stream_type, control_handle } = self {
            Some((stream_type, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_capture_at(self) -> Option<(u32, u32, u32, AudioCapturerCaptureAtResponder)> {
        if let AudioCapturerRequest::CaptureAt {
            payload_buffer_id,
            payload_offset,
            frames,
            responder,
        } = self
        {
            Some((payload_buffer_id, payload_offset, frames, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_async_capture(self) -> Option<(u32, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::StartAsyncCapture { frames_per_packet, control_handle } = self
        {
            Some((frames_per_packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_async_capture(self) -> Option<(AudioCapturerStopAsyncCaptureResponder)> {
        if let AudioCapturerRequest::StopAsyncCapture { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_async_capture_no_reply(self) -> Option<(AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::StopAsyncCaptureNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_gain_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
        AudioCapturerControlHandle,
    )> {
        if let AudioCapturerRequest::BindGainControl { gain_control_request, control_handle } = self
        {
            Some((gain_control_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reference_clock(self) -> Option<(AudioCapturerGetReferenceClockResponder)> {
        if let AudioCapturerRequest::GetReferenceClock { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reference_clock(
        self,
    ) -> Option<(Option<fidl::Clock>, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::SetReferenceClock { reference_clock, control_handle } = self {
            Some((reference_clock, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_usage(self) -> Option<(AudioCaptureUsage, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::SetUsage { usage, control_handle } = self {
            Some((usage, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_usage2(self) -> Option<(AudioCaptureUsage2, AudioCapturerControlHandle)> {
        if let AudioCapturerRequest::SetUsage2 { usage, control_handle } = self {
            Some((usage, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_stream_type(self) -> Option<(AudioCapturerGetStreamTypeResponder)> {
        if let AudioCapturerRequest::GetStreamType { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioCapturerRequest::AddPayloadBuffer { .. } => "add_payload_buffer",
            AudioCapturerRequest::RemovePayloadBuffer { .. } => "remove_payload_buffer",
            AudioCapturerRequest::ReleasePacket { .. } => "release_packet",
            AudioCapturerRequest::DiscardAllPackets { .. } => "discard_all_packets",
            AudioCapturerRequest::DiscardAllPacketsNoReply { .. } => "discard_all_packets_no_reply",
            AudioCapturerRequest::SetPcmStreamType { .. } => "set_pcm_stream_type",
            AudioCapturerRequest::CaptureAt { .. } => "capture_at",
            AudioCapturerRequest::StartAsyncCapture { .. } => "start_async_capture",
            AudioCapturerRequest::StopAsyncCapture { .. } => "stop_async_capture",
            AudioCapturerRequest::StopAsyncCaptureNoReply { .. } => "stop_async_capture_no_reply",
            AudioCapturerRequest::BindGainControl { .. } => "bind_gain_control",
            AudioCapturerRequest::GetReferenceClock { .. } => "get_reference_clock",
            AudioCapturerRequest::SetReferenceClock { .. } => "set_reference_clock",
            AudioCapturerRequest::SetUsage { .. } => "set_usage",
            AudioCapturerRequest::SetUsage2 { .. } => "set_usage2",
            AudioCapturerRequest::GetStreamType { .. } => "get_stream_type",
            AudioCapturerRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            AudioCapturerRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioCapturerControlHandle {
    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 AudioCapturerControlHandle {
    pub fn send_on_packet_produced(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.inner.send::<StreamSourceOnPacketProducedRequest>(
            (packet,),
            0,
            0x6bbe69746a3c8bd9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_end_of_stream(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x550e69b41d03e2c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut captured_packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioCapturerCaptureAtResponse>(
            (captured_packet,),
            self.tx_id,
            0x784e25df72cea780,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut reference_clock: fidl::Clock) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioCapturerGetReferenceClockResponse>(
            (reference_clock,),
            self.tx_id,
            0x50d037aa5a4b4d71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut stream_type: &StreamType) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioCapturerGetStreamTypeResponse>(
            (stream_type,),
            self.tx_id,
            0x5dcaaa670b433088,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for AudioConsumerMarker {
    type Proxy = AudioConsumerProxy;
    type RequestStream = AudioConsumerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioConsumerSynchronousProxy;

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

pub trait AudioConsumerProxyInterface: Send + Sync {
    fn r#create_stream_sink(
        &self,
        buffers: Vec<fidl::Vmo>,
        stream_type: &AudioStreamType,
        compression: Option<&Compression>,
        stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#start(
        &self,
        flags: AudioConsumerStartFlags,
        reference_time: i64,
        media_time: i64,
    ) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
    fn r#set_rate(&self, rate: f32) -> Result<(), fidl::Error>;
    fn r#bind_volume_control(
        &self,
        volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type WatchStatusResponseFut: std::future::Future<Output = Result<AudioConsumerStatus, fidl::Error>>
        + Send;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioConsumerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioConsumerSynchronousProxy {
    type Proxy = AudioConsumerProxy;
    type Protocol = AudioConsumerMarker;

    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 AudioConsumerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioConsumerMarker 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<AudioConsumerEvent, fidl::Error> {
        AudioConsumerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a `StreamSink` for the consumer with the indicated properties.
    ///
    /// Multiple stream sinks may be acquired using this method, but they are intended to be used
    /// sequentially rather than concurrently. The first stream sink that's created using this
    /// method is used as the sole source of packets incoming to the logical consumer until that
    /// stream sink is closed or the `EndOfStream` method is called on that sink. At that point,
    /// the second stream sink is used, and so on.
    ///
    /// If an unsupported compression type is supplied, the
    /// `stream_sink_request` request will be closed with an epitaph value of
    /// `ZX_ERR_INVALID_ARGS`.
    pub fn r#create_stream_sink(
        &self,
        mut buffers: Vec<fidl::Vmo>,
        mut stream_type: &AudioStreamType,
        mut compression: Option<&Compression>,
        mut stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerCreateStreamSinkRequest>(
            (buffers.as_mut(), stream_type, compression, stream_sink_request),
            0x525b3b97fdf7d884,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Starts rendering as indicated by `flags`.
    ///
    /// `media_time` indicates the packet timestamp that corresponds to `reference_time`.
    /// Typically, this is the timestamp of the first packet that will be
    /// rendered. If packets will be supplied with no timestamps, this value
    /// should be `NO_TIMESTAMP`.  Passing a `media_time` value of
    /// `NO_TIMESTAMP` chooses the default media time, established as follows:
    ///     1. When starting for the first time, the default media time is the
    ///        timestamp on the first packet sent to the stream sink.
    ///     2. When resuming after stop, the default media time is the media
    ///        time at which the stream stopped.
    ///
    /// `reference_time` is the monotonic system time at which rendering should
    /// be started. For supply-driven sources, this must be the time at which
    /// the first packet was (or will be) sent plus a lead time, which must be
    /// in the range indicated in the `AudioConsumerStatus`. For demand-driven
    /// sources, the client must ensure that the lead time requirement is met at
    /// the start time.  Passing the default value of 0 for `reference_time`
    /// causes the consumer to choose a start time based on the availability of
    /// packets, the lead time requirements, and whether `LOW_LATENCY` has been
    /// specified.
    ///
    /// The actual start time will be reflected in the updated status.
    pub fn r#start(
        &self,
        mut flags: AudioConsumerStartFlags,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerStartRequest>(
            (flags, reference_time, media_time),
            0x4fdbd44b3f2a3a3c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops rendering as soon as possible after this method is called. The actual stop time will
    /// be reflected in the updated status.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x3d46c3741686c40d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Requests to change the playback rate of the renderer. 1.0 means normal
    /// playback. Negative rates are not supported. The new rate will be
    /// reflected in the updated status. The default rate of any newly created `StreamSink` is 1.0.
    pub fn r#set_rate(&self, mut rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerSetRateRequest>(
            (rate,),
            0x45342b73968bfafe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to this `AudioConsumer` volume control for control and notifications.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerBindVolumeControlRequest>(
            (volume_control_request,),
            0x6f1b01fd887f5748,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Gets the current status of the consumer using the long get pattern. The consumer responds
    /// to this method when the status changes - initially with respect to the initial status value
    /// and thereafter with respect to the previously-reported status value.
    pub fn r#watch_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AudioConsumerStatus, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioConsumerWatchStatusResponse>(
                (),
                0x35cf702c721e2cc6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioConsumerProxy {
    type Protocol = AudioConsumerMarker;

    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 AudioConsumerProxy {
    /// Create a new Proxy for fuchsia.media/AudioConsumer.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioConsumerMarker 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) -> AudioConsumerEventStream {
        AudioConsumerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a `StreamSink` for the consumer with the indicated properties.
    ///
    /// Multiple stream sinks may be acquired using this method, but they are intended to be used
    /// sequentially rather than concurrently. The first stream sink that's created using this
    /// method is used as the sole source of packets incoming to the logical consumer until that
    /// stream sink is closed or the `EndOfStream` method is called on that sink. At that point,
    /// the second stream sink is used, and so on.
    ///
    /// If an unsupported compression type is supplied, the
    /// `stream_sink_request` request will be closed with an epitaph value of
    /// `ZX_ERR_INVALID_ARGS`.
    pub fn r#create_stream_sink(
        &self,
        mut buffers: Vec<fidl::Vmo>,
        mut stream_type: &AudioStreamType,
        mut compression: Option<&Compression>,
        mut stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
    ) -> Result<(), fidl::Error> {
        AudioConsumerProxyInterface::r#create_stream_sink(
            self,
            buffers,
            stream_type,
            compression,
            stream_sink_request,
        )
    }

    /// Starts rendering as indicated by `flags`.
    ///
    /// `media_time` indicates the packet timestamp that corresponds to `reference_time`.
    /// Typically, this is the timestamp of the first packet that will be
    /// rendered. If packets will be supplied with no timestamps, this value
    /// should be `NO_TIMESTAMP`.  Passing a `media_time` value of
    /// `NO_TIMESTAMP` chooses the default media time, established as follows:
    ///     1. When starting for the first time, the default media time is the
    ///        timestamp on the first packet sent to the stream sink.
    ///     2. When resuming after stop, the default media time is the media
    ///        time at which the stream stopped.
    ///
    /// `reference_time` is the monotonic system time at which rendering should
    /// be started. For supply-driven sources, this must be the time at which
    /// the first packet was (or will be) sent plus a lead time, which must be
    /// in the range indicated in the `AudioConsumerStatus`. For demand-driven
    /// sources, the client must ensure that the lead time requirement is met at
    /// the start time.  Passing the default value of 0 for `reference_time`
    /// causes the consumer to choose a start time based on the availability of
    /// packets, the lead time requirements, and whether `LOW_LATENCY` has been
    /// specified.
    ///
    /// The actual start time will be reflected in the updated status.
    pub fn r#start(
        &self,
        mut flags: AudioConsumerStartFlags,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        AudioConsumerProxyInterface::r#start(self, flags, reference_time, media_time)
    }

    /// Stops rendering as soon as possible after this method is called. The actual stop time will
    /// be reflected in the updated status.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        AudioConsumerProxyInterface::r#stop(self)
    }

    /// Requests to change the playback rate of the renderer. 1.0 means normal
    /// playback. Negative rates are not supported. The new rate will be
    /// reflected in the updated status. The default rate of any newly created `StreamSink` is 1.0.
    pub fn r#set_rate(&self, mut rate: f32) -> Result<(), fidl::Error> {
        AudioConsumerProxyInterface::r#set_rate(self, rate)
    }

    /// Binds to this `AudioConsumer` volume control for control and notifications.
    pub fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AudioConsumerProxyInterface::r#bind_volume_control(self, volume_control_request)
    }

    /// Gets the current status of the consumer using the long get pattern. The consumer responds
    /// to this method when the status changes - initially with respect to the initial status value
    /// and thereafter with respect to the previously-reported status value.
    pub fn r#watch_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AudioConsumerStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AudioConsumerProxyInterface::r#watch_status(self)
    }
}

impl AudioConsumerProxyInterface for AudioConsumerProxy {
    fn r#create_stream_sink(
        &self,
        mut buffers: Vec<fidl::Vmo>,
        mut stream_type: &AudioStreamType,
        mut compression: Option<&Compression>,
        mut stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerCreateStreamSinkRequest>(
            (buffers.as_mut(), stream_type, compression, stream_sink_request),
            0x525b3b97fdf7d884,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#start(
        &self,
        mut flags: AudioConsumerStartFlags,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerStartRequest>(
            (flags, reference_time, media_time),
            0x4fdbd44b3f2a3a3c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x3d46c3741686c40d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_rate(&self, mut rate: f32) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerSetRateRequest>(
            (rate,),
            0x45342b73968bfafe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_volume_control(
        &self,
        mut volume_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioConsumerBindVolumeControlRequest>(
            (volume_control_request,),
            0x6f1b01fd887f5748,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchStatusResponseFut = fidl::client::QueryResponseFut<
        AudioConsumerStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioConsumerStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioConsumerWatchStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35cf702c721e2cc6,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, AudioConsumerStatus>(
            (),
            0x35cf702c721e2cc6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum AudioConsumerEvent {
    OnEndOfStream {},
}

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

    /// Decodes a message buffer as a [`AudioConsumerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AudioConsumerEvent, 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 {
            0x53a64e6d0e8f8a20 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioConsumerEvent::OnEndOfStream {}))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <AudioConsumerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for AudioConsumerRequestStream {
    type Protocol = AudioConsumerMarker;
    type ControlHandle = AudioConsumerControlHandle;

    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 {
        AudioConsumerControlHandle { 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 AudioConsumerRequestStream {
    type Item = Result<AudioConsumerRequest, 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 AudioConsumerRequestStream 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 {
                    0x525b3b97fdf7d884 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioConsumerCreateStreamSinkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioConsumerCreateStreamSinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::CreateStreamSink {
                            buffers: req.buffers,
                            stream_type: req.stream_type,
                            compression: req.compression,
                            stream_sink_request: req.stream_sink_request,

                            control_handle,
                        })
                    }
                    0x4fdbd44b3f2a3a3c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioConsumerStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioConsumerStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::Start {
                            flags: req.flags,
                            reference_time: req.reference_time,
                            media_time: req.media_time,

                            control_handle,
                        })
                    }
                    0x3d46c3741686c40d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::Stop { control_handle })
                    }
                    0x45342b73968bfafe => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioConsumerSetRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioConsumerSetRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::SetRate { rate: req.rate, control_handle })
                    }
                    0x6f1b01fd887f5748 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioConsumerBindVolumeControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioConsumerBindVolumeControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::BindVolumeControl {
                            volume_control_request: req.volume_control_request,

                            control_handle,
                        })
                    }
                    0x35cf702c721e2cc6 => {
                        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 =
                            AudioConsumerControlHandle { inner: this.inner.clone() };
                        Ok(AudioConsumerRequest::WatchStatus {
                            responder: AudioConsumerWatchStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AudioConsumerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Interface for playing and controlling audio.
#[derive(Debug)]
pub enum AudioConsumerRequest {
    /// Creates a `StreamSink` for the consumer with the indicated properties.
    ///
    /// Multiple stream sinks may be acquired using this method, but they are intended to be used
    /// sequentially rather than concurrently. The first stream sink that's created using this
    /// method is used as the sole source of packets incoming to the logical consumer until that
    /// stream sink is closed or the `EndOfStream` method is called on that sink. At that point,
    /// the second stream sink is used, and so on.
    ///
    /// If an unsupported compression type is supplied, the
    /// `stream_sink_request` request will be closed with an epitaph value of
    /// `ZX_ERR_INVALID_ARGS`.
    CreateStreamSink {
        buffers: Vec<fidl::Vmo>,
        stream_type: AudioStreamType,
        compression: Option<Box<Compression>>,
        stream_sink_request: fidl::endpoints::ServerEnd<StreamSinkMarker>,
        control_handle: AudioConsumerControlHandle,
    },
    /// Starts rendering as indicated by `flags`.
    ///
    /// `media_time` indicates the packet timestamp that corresponds to `reference_time`.
    /// Typically, this is the timestamp of the first packet that will be
    /// rendered. If packets will be supplied with no timestamps, this value
    /// should be `NO_TIMESTAMP`.  Passing a `media_time` value of
    /// `NO_TIMESTAMP` chooses the default media time, established as follows:
    ///     1. When starting for the first time, the default media time is the
    ///        timestamp on the first packet sent to the stream sink.
    ///     2. When resuming after stop, the default media time is the media
    ///        time at which the stream stopped.
    ///
    /// `reference_time` is the monotonic system time at which rendering should
    /// be started. For supply-driven sources, this must be the time at which
    /// the first packet was (or will be) sent plus a lead time, which must be
    /// in the range indicated in the `AudioConsumerStatus`. For demand-driven
    /// sources, the client must ensure that the lead time requirement is met at
    /// the start time.  Passing the default value of 0 for `reference_time`
    /// causes the consumer to choose a start time based on the availability of
    /// packets, the lead time requirements, and whether `LOW_LATENCY` has been
    /// specified.
    ///
    /// The actual start time will be reflected in the updated status.
    Start {
        flags: AudioConsumerStartFlags,
        reference_time: i64,
        media_time: i64,
        control_handle: AudioConsumerControlHandle,
    },
    /// Stops rendering as soon as possible after this method is called. The actual stop time will
    /// be reflected in the updated status.
    Stop { control_handle: AudioConsumerControlHandle },
    /// Requests to change the playback rate of the renderer. 1.0 means normal
    /// playback. Negative rates are not supported. The new rate will be
    /// reflected in the updated status. The default rate of any newly created `StreamSink` is 1.0.
    SetRate { rate: f32, control_handle: AudioConsumerControlHandle },
    /// Binds to this `AudioConsumer` volume control for control and notifications.
    BindVolumeControl {
        volume_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: AudioConsumerControlHandle,
    },
    /// Gets the current status of the consumer using the long get pattern. The consumer responds
    /// to this method when the status changes - initially with respect to the initial status value
    /// and thereafter with respect to the previously-reported status value.
    WatchStatus { responder: AudioConsumerWatchStatusResponder },
}

impl AudioConsumerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_stream_sink(
        self,
    ) -> Option<(
        Vec<fidl::Vmo>,
        AudioStreamType,
        Option<Box<Compression>>,
        fidl::endpoints::ServerEnd<StreamSinkMarker>,
        AudioConsumerControlHandle,
    )> {
        if let AudioConsumerRequest::CreateStreamSink {
            buffers,
            stream_type,
            compression,
            stream_sink_request,
            control_handle,
        } = self
        {
            Some((buffers, stream_type, compression, stream_sink_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(AudioConsumerStartFlags, i64, i64, AudioConsumerControlHandle)> {
        if let AudioConsumerRequest::Start { flags, reference_time, media_time, control_handle } =
            self
        {
            Some((flags, reference_time, media_time, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_rate(self) -> Option<(f32, AudioConsumerControlHandle)> {
        if let AudioConsumerRequest::SetRate { rate, control_handle } = self {
            Some((rate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_volume_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        AudioConsumerControlHandle,
    )> {
        if let AudioConsumerRequest::BindVolumeControl { volume_control_request, control_handle } =
            self
        {
            Some((volume_control_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_status(self) -> Option<(AudioConsumerWatchStatusResponder)> {
        if let AudioConsumerRequest::WatchStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioConsumerRequest::CreateStreamSink { .. } => "create_stream_sink",
            AudioConsumerRequest::Start { .. } => "start",
            AudioConsumerRequest::Stop { .. } => "stop",
            AudioConsumerRequest::SetRate { .. } => "set_rate",
            AudioConsumerRequest::BindVolumeControl { .. } => "bind_volume_control",
            AudioConsumerRequest::WatchStatus { .. } => "watch_status",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioConsumerControlHandle {
    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 AudioConsumerControlHandle {
    pub fn send_on_end_of_stream(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x53a64e6d0e8f8a20,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: &AudioConsumerStatus) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioConsumerWatchStatusResponse>(
            (status,),
            self.tx_id,
            0x35cf702c721e2cc6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for AudioCoreMarker {
    type Proxy = AudioCoreProxy;
    type RequestStream = AudioCoreRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioCoreSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.AudioCore";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioCoreMarker {}

pub trait AudioCoreProxyInterface: Send + Sync {
    fn r#create_audio_renderer(
        &self,
        audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer_with_configuration(
        &self,
        stream_type: &AudioStreamType,
        configuration: &AudioCapturerConfiguration,
        audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer(
        &self,
        loopback: bool,
        audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_render_usage_gain(
        &self,
        usage: AudioRenderUsage,
        gain_db: f32,
    ) -> Result<(), fidl::Error>;
    fn r#set_render_usage_gain2(
        &self,
        usage: AudioRenderUsage2,
        gain_db: f32,
    ) -> Result<(), fidl::Error>;
    fn r#set_capture_usage_gain(
        &self,
        usage: AudioCaptureUsage,
        gain_db: f32,
    ) -> Result<(), fidl::Error>;
    fn r#set_capture_usage_gain2(
        &self,
        usage: AudioCaptureUsage2,
        gain_db: f32,
    ) -> Result<(), fidl::Error>;
    fn r#bind_usage_volume_control(
        &self,
        usage: &Usage,
        volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#bind_usage_volume_control2(
        &self,
        usage: &Usage2,
        volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
    ) -> Result<(), fidl::Error>;
    type GetVolumeFromDbResponseFut: std::future::Future<Output = Result<f32, fidl::Error>> + Send;
    fn r#get_volume_from_db(&self, usage: &Usage, gain_db: f32)
    -> Self::GetVolumeFromDbResponseFut;
    type GetVolumeFromDb2ResponseFut: std::future::Future<Output = Result<f32, fidl::Error>> + Send;
    fn r#get_volume_from_db2(
        &self,
        usage: &Usage2,
        gain_db: f32,
    ) -> Self::GetVolumeFromDb2ResponseFut;
    type GetDbFromVolumeResponseFut: std::future::Future<Output = Result<f32, fidl::Error>> + Send;
    fn r#get_db_from_volume(&self, usage: &Usage, volume: f32) -> Self::GetDbFromVolumeResponseFut;
    type GetDbFromVolume2ResponseFut: std::future::Future<Output = Result<f32, fidl::Error>> + Send;
    fn r#get_db_from_volume2(
        &self,
        usage: &Usage2,
        volume: f32,
    ) -> Self::GetDbFromVolume2ResponseFut;
    fn r#set_interaction(
        &self,
        active: &Usage,
        affected: &Usage,
        behavior: Behavior,
    ) -> Result<(), fidl::Error>;
    fn r#set_interaction2(
        &self,
        active: &Usage2,
        affected: &Usage2,
        behavior: Behavior,
    ) -> Result<(), fidl::Error>;
    fn r#reset_interactions(&self) -> Result<(), fidl::Error>;
    fn r#load_defaults(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioCoreSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioCoreSynchronousProxy {
    type Proxy = AudioCoreProxy;
    type Protocol = AudioCoreMarker;

    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 AudioCoreSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioCoreMarker 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<AudioCoreEvent, fidl::Error> {
        AudioCoreEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates an AudioRenderer which outputs audio to the default device.
    pub fn r#create_audio_renderer(
        &self,
        mut audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioRendererRequest>(
            (audio_out_request,),
            0x2ac9beba47f83435,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates an AudioCapturer according to the given requirements.
    ///
    /// `pcm_stream_type` sets the stream type of the stream to be delivered.
    /// It causes the source material to be reformatted/resampled if needed
    /// in order to produce the requested stream type.
    ///
    /// `usage` is used by Fuchsia to make decisions about user experience.
    /// See `AudioCaptureUsage` for more details.
    ///
    /// `configuration` must be initialized to a variant, or no capturer
    /// can be created.
    pub fn r#create_audio_capturer_with_configuration(
        &self,
        mut stream_type: &AudioStreamType,
        mut configuration: &AudioCapturerConfiguration,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioCapturerWithConfigurationRequest>(
            (stream_type, configuration, audio_capturer_request),
            0x459de383b0d76d97,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    pub fn r#create_audio_capturer(
        &self,
        mut loopback: bool,
        mut audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioCapturerRequest>(
            (loopback, audio_in_request),
            0x787db169df99aed0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    pub fn r#set_render_usage_gain(
        &self,
        mut usage: AudioRenderUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetRenderUsageGainRequest>(
            (usage, gain_db),
            0x48097f45f6e2b8e7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    pub fn r#set_render_usage_gain2(
        &self,
        mut usage: AudioRenderUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetRenderUsageGain2Request>(
            (usage, gain_db),
            0x779b1531dc9e64f4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    pub fn r#set_capture_usage_gain(
        &self,
        mut usage: AudioCaptureUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetCaptureUsageGainRequest>(
            (usage, gain_db),
            0x457d29217d4ea248,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    pub fn r#set_capture_usage_gain2(
        &self,
        mut usage: AudioCaptureUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetCaptureUsageGain2Request>(
            (usage, gain_db),
            0x15065ee308f44af0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Binds to a volume control protocol for the given usage.
    pub fn r#bind_usage_volume_control(
        &self,
        mut usage: &Usage,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreBindUsageVolumeControlRequest>(
            (usage, volume_control),
            0x7225be116aadc137,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to a volume control protocol for the given usage.
    pub fn r#bind_usage_volume_control2(
        &self,
        mut usage: &Usage2,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreBindUsageVolumeControl2Request>(
            (usage, volume_control),
            0x729dff93019d055,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    pub fn r#get_volume_from_db(
        &self,
        mut usage: &Usage,
        mut gain_db: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<f32, fidl::Error> {
        let _response = self
            .client
            .send_query::<AudioCoreGetVolumeFromDbRequest, AudioCoreGetVolumeFromDbResponse>(
                (usage, gain_db),
                0x50e3ca45509770bf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.volume)
    }

    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    pub fn r#get_volume_from_db2(
        &self,
        mut usage: &Usage2,
        mut gain_db: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<f32, fidl::Error> {
        let _response = self.client.send_query::<
            AudioCoreGetVolumeFromDb2Request,
            fidl::encoding::FlexibleType<AudioCoreGetVolumeFromDb2Response>,
        >(
            (usage, gain_db,),
            0x165c811091ef99da,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<AudioCoreMarker>("get_volume_from_db2")?;
        Ok(_response.volume)
    }

    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    pub fn r#get_db_from_volume(
        &self,
        mut usage: &Usage,
        mut volume: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<f32, fidl::Error> {
        let _response = self
            .client
            .send_query::<AudioCoreGetDbFromVolumeRequest, AudioCoreGetDbFromVolumeResponse>(
                (usage, volume),
                0x3e8eec27dd5a8bda,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.gain_db)
    }

    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    pub fn r#get_db_from_volume2(
        &self,
        mut usage: &Usage2,
        mut volume: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<f32, fidl::Error> {
        let _response = self.client.send_query::<
            AudioCoreGetDbFromVolume2Request,
            fidl::encoding::FlexibleType<AudioCoreGetDbFromVolume2Response>,
        >(
            (usage, volume,),
            0x5f421a8ebf265bf3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<AudioCoreMarker>("get_db_from_volume2")?;
        Ok(_response.gain_db)
    }

    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    pub fn r#set_interaction(
        &self,
        mut active: &Usage,
        mut affected: &Usage,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetInteractionRequest>(
            (active, affected, behavior),
            0x7bfed14345ece7b7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    pub fn r#set_interaction2(
        &self,
        mut active: &Usage2,
        mut affected: &Usage2,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetInteraction2Request>(
            (active, affected, behavior),
            0x7226c7c6e6edc62f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Re-initializes the set of rules that are currently governing the interaction of streams in
    /// audio_core. The default behavior is 'NONE'.
    pub fn r#reset_interactions(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x65bd94d9d0a28b5e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Re-loads the platform policy configuration. Falls back to a default config if the platform
    /// does not provide a config.
    pub fn r#load_defaults(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x54a0bebca85f6b31,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioCoreProxy {
    type Protocol = AudioCoreMarker;

    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 AudioCoreProxy {
    /// Create a new Proxy for fuchsia.media/AudioCore.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioCoreMarker 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) -> AudioCoreEventStream {
        AudioCoreEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates an AudioRenderer which outputs audio to the default device.
    pub fn r#create_audio_renderer(
        &self,
        mut audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#create_audio_renderer(self, audio_out_request)
    }

    /// Creates an AudioCapturer according to the given requirements.
    ///
    /// `pcm_stream_type` sets the stream type of the stream to be delivered.
    /// It causes the source material to be reformatted/resampled if needed
    /// in order to produce the requested stream type.
    ///
    /// `usage` is used by Fuchsia to make decisions about user experience.
    /// See `AudioCaptureUsage` for more details.
    ///
    /// `configuration` must be initialized to a variant, or no capturer
    /// can be created.
    pub fn r#create_audio_capturer_with_configuration(
        &self,
        mut stream_type: &AudioStreamType,
        mut configuration: &AudioCapturerConfiguration,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#create_audio_capturer_with_configuration(
            self,
            stream_type,
            configuration,
            audio_capturer_request,
        )
    }

    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    pub fn r#create_audio_capturer(
        &self,
        mut loopback: bool,
        mut audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#create_audio_capturer(self, loopback, audio_in_request)
    }

    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    pub fn r#set_render_usage_gain(
        &self,
        mut usage: AudioRenderUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_render_usage_gain(self, usage, gain_db)
    }

    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    pub fn r#set_render_usage_gain2(
        &self,
        mut usage: AudioRenderUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_render_usage_gain2(self, usage, gain_db)
    }

    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    pub fn r#set_capture_usage_gain(
        &self,
        mut usage: AudioCaptureUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_capture_usage_gain(self, usage, gain_db)
    }

    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    pub fn r#set_capture_usage_gain2(
        &self,
        mut usage: AudioCaptureUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_capture_usage_gain2(self, usage, gain_db)
    }

    /// Binds to a volume control protocol for the given usage.
    pub fn r#bind_usage_volume_control(
        &self,
        mut usage: &Usage,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#bind_usage_volume_control(self, usage, volume_control)
    }

    /// Binds to a volume control protocol for the given usage.
    pub fn r#bind_usage_volume_control2(
        &self,
        mut usage: &Usage2,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#bind_usage_volume_control2(self, usage, volume_control)
    }

    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    pub fn r#get_volume_from_db(
        &self,
        mut usage: &Usage,
        mut gain_db: f32,
    ) -> fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCoreProxyInterface::r#get_volume_from_db(self, usage, gain_db)
    }

    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    pub fn r#get_volume_from_db2(
        &self,
        mut usage: &Usage2,
        mut gain_db: f32,
    ) -> fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCoreProxyInterface::r#get_volume_from_db2(self, usage, gain_db)
    }

    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    pub fn r#get_db_from_volume(
        &self,
        mut usage: &Usage,
        mut volume: f32,
    ) -> fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCoreProxyInterface::r#get_db_from_volume(self, usage, volume)
    }

    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    pub fn r#get_db_from_volume2(
        &self,
        mut usage: &Usage2,
        mut volume: f32,
    ) -> fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioCoreProxyInterface::r#get_db_from_volume2(self, usage, volume)
    }

    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    pub fn r#set_interaction(
        &self,
        mut active: &Usage,
        mut affected: &Usage,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_interaction(self, active, affected, behavior)
    }

    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    pub fn r#set_interaction2(
        &self,
        mut active: &Usage2,
        mut affected: &Usage2,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#set_interaction2(self, active, affected, behavior)
    }

    /// Re-initializes the set of rules that are currently governing the interaction of streams in
    /// audio_core. The default behavior is 'NONE'.
    pub fn r#reset_interactions(&self) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#reset_interactions(self)
    }

    /// Re-loads the platform policy configuration. Falls back to a default config if the platform
    /// does not provide a config.
    pub fn r#load_defaults(&self) -> Result<(), fidl::Error> {
        AudioCoreProxyInterface::r#load_defaults(self)
    }
}

impl AudioCoreProxyInterface for AudioCoreProxy {
    fn r#create_audio_renderer(
        &self,
        mut audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioRendererRequest>(
            (audio_out_request,),
            0x2ac9beba47f83435,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_audio_capturer_with_configuration(
        &self,
        mut stream_type: &AudioStreamType,
        mut configuration: &AudioCapturerConfiguration,
        mut audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioCapturerWithConfigurationRequest>(
            (stream_type, configuration, audio_capturer_request),
            0x459de383b0d76d97,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_audio_capturer(
        &self,
        mut loopback: bool,
        mut audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreCreateAudioCapturerRequest>(
            (loopback, audio_in_request),
            0x787db169df99aed0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_render_usage_gain(
        &self,
        mut usage: AudioRenderUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetRenderUsageGainRequest>(
            (usage, gain_db),
            0x48097f45f6e2b8e7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_render_usage_gain2(
        &self,
        mut usage: AudioRenderUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetRenderUsageGain2Request>(
            (usage, gain_db),
            0x779b1531dc9e64f4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#set_capture_usage_gain(
        &self,
        mut usage: AudioCaptureUsage,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetCaptureUsageGainRequest>(
            (usage, gain_db),
            0x457d29217d4ea248,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_capture_usage_gain2(
        &self,
        mut usage: AudioCaptureUsage2,
        mut gain_db: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetCaptureUsageGain2Request>(
            (usage, gain_db),
            0x15065ee308f44af0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#bind_usage_volume_control(
        &self,
        mut usage: &Usage,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreBindUsageVolumeControlRequest>(
            (usage, volume_control),
            0x7225be116aadc137,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_usage_volume_control2(
        &self,
        mut usage: &Usage2,
        mut volume_control: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreBindUsageVolumeControl2Request>(
            (usage, volume_control),
            0x729dff93019d055,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type GetVolumeFromDbResponseFut =
        fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_volume_from_db(
        &self,
        mut usage: &Usage,
        mut gain_db: f32,
    ) -> Self::GetVolumeFromDbResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCoreGetVolumeFromDbResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50e3ca45509770bf,
            >(_buf?)?;
            Ok(_response.volume)
        }
        self.client.send_query_and_decode::<AudioCoreGetVolumeFromDbRequest, f32>(
            (usage, gain_db),
            0x50e3ca45509770bf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetVolumeFromDb2ResponseFut =
        fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_volume_from_db2(
        &self,
        mut usage: &Usage2,
        mut gain_db: f32,
    ) -> Self::GetVolumeFromDb2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AudioCoreGetVolumeFromDb2Response>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x165c811091ef99da,
            >(_buf?)?
            .into_result::<AudioCoreMarker>("get_volume_from_db2")?;
            Ok(_response.volume)
        }
        self.client.send_query_and_decode::<AudioCoreGetVolumeFromDb2Request, f32>(
            (usage, gain_db),
            0x165c811091ef99da,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetDbFromVolumeResponseFut =
        fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_db_from_volume(
        &self,
        mut usage: &Usage,
        mut volume: f32,
    ) -> Self::GetDbFromVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCoreGetDbFromVolumeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3e8eec27dd5a8bda,
            >(_buf?)?;
            Ok(_response.gain_db)
        }
        self.client.send_query_and_decode::<AudioCoreGetDbFromVolumeRequest, f32>(
            (usage, volume),
            0x3e8eec27dd5a8bda,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetDbFromVolume2ResponseFut =
        fidl::client::QueryResponseFut<f32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_db_from_volume2(
        &self,
        mut usage: &Usage2,
        mut volume: f32,
    ) -> Self::GetDbFromVolume2ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AudioCoreGetDbFromVolume2Response>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f421a8ebf265bf3,
            >(_buf?)?
            .into_result::<AudioCoreMarker>("get_db_from_volume2")?;
            Ok(_response.gain_db)
        }
        self.client.send_query_and_decode::<AudioCoreGetDbFromVolume2Request, f32>(
            (usage, volume),
            0x5f421a8ebf265bf3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    fn r#set_interaction(
        &self,
        mut active: &Usage,
        mut affected: &Usage,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetInteractionRequest>(
            (active, affected, behavior),
            0x7bfed14345ece7b7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_interaction2(
        &self,
        mut active: &Usage2,
        mut affected: &Usage2,
        mut behavior: Behavior,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCoreSetInteraction2Request>(
            (active, affected, behavior),
            0x7226c7c6e6edc62f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#reset_interactions(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x65bd94d9d0a28b5e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#load_defaults(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x54a0bebca85f6b31,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AudioCoreRequestStream {
    type Protocol = AudioCoreMarker;
    type ControlHandle = AudioCoreControlHandle;

    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 {
        AudioCoreControlHandle { 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 AudioCoreRequestStream {
    type Item = Result<AudioCoreRequest, 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 AudioCoreRequestStream 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 {
                    0x2ac9beba47f83435 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreCreateAudioRendererRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreCreateAudioRendererRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::CreateAudioRenderer {
                            audio_out_request: req.audio_out_request,

                            control_handle,
                        })
                    }
                    0x459de383b0d76d97 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreCreateAudioCapturerWithConfigurationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreCreateAudioCapturerWithConfigurationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::CreateAudioCapturerWithConfiguration {
                            stream_type: req.stream_type,
                            configuration: req.configuration,
                            audio_capturer_request: req.audio_capturer_request,

                            control_handle,
                        })
                    }
                    0x787db169df99aed0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreCreateAudioCapturerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreCreateAudioCapturerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::CreateAudioCapturer {
                            loopback: req.loopback,
                            audio_in_request: req.audio_in_request,

                            control_handle,
                        })
                    }
                    0x48097f45f6e2b8e7 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetRenderUsageGainRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetRenderUsageGainRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetRenderUsageGain {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            control_handle,
                        })
                    }
                    0x779b1531dc9e64f4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetRenderUsageGain2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetRenderUsageGain2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetRenderUsageGain2 {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            control_handle,
                        })
                    }
                    0x457d29217d4ea248 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetCaptureUsageGainRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetCaptureUsageGainRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetCaptureUsageGain {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            control_handle,
                        })
                    }
                    0x15065ee308f44af0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetCaptureUsageGain2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetCaptureUsageGain2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetCaptureUsageGain2 {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            control_handle,
                        })
                    }
                    0x7225be116aadc137 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreBindUsageVolumeControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreBindUsageVolumeControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::BindUsageVolumeControl {
                            usage: req.usage,
                            volume_control: req.volume_control,

                            control_handle,
                        })
                    }
                    0x729dff93019d055 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreBindUsageVolumeControl2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreBindUsageVolumeControl2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::BindUsageVolumeControl2 {
                            usage: req.usage,
                            volume_control: req.volume_control,

                            control_handle,
                        })
                    }
                    0x50e3ca45509770bf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreGetVolumeFromDbRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreGetVolumeFromDbRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::GetVolumeFromDb {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            responder: AudioCoreGetVolumeFromDbResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x165c811091ef99da => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreGetVolumeFromDb2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreGetVolumeFromDb2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::GetVolumeFromDb2 {
                            usage: req.usage,
                            gain_db: req.gain_db,

                            responder: AudioCoreGetVolumeFromDb2Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3e8eec27dd5a8bda => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreGetDbFromVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreGetDbFromVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::GetDbFromVolume {
                            usage: req.usage,
                            volume: req.volume,

                            responder: AudioCoreGetDbFromVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5f421a8ebf265bf3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreGetDbFromVolume2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreGetDbFromVolume2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::GetDbFromVolume2 {
                            usage: req.usage,
                            volume: req.volume,

                            responder: AudioCoreGetDbFromVolume2Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7bfed14345ece7b7 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetInteractionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetInteractionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetInteraction {
                            active: req.active,
                            affected: req.affected,
                            behavior: req.behavior,

                            control_handle,
                        })
                    }
                    0x7226c7c6e6edc62f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioCoreSetInteraction2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioCoreSetInteraction2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::SetInteraction2 {
                            active: req.active,
                            affected: req.affected,
                            behavior: req.behavior,

                            control_handle,
                        })
                    }
                    0x65bd94d9d0a28b5e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::ResetInteractions { control_handle })
                    }
                    0x54a0bebca85f6b31 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 = AudioCoreControlHandle { inner: this.inner.clone() };
                        Ok(AudioCoreRequest::LoadDefaults { control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AudioCoreRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioCoreControlHandle { 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(AudioCoreRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioCoreControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AudioCoreMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum AudioCoreRequest {
    /// Creates an AudioRenderer which outputs audio to the default device.
    CreateAudioRenderer {
        audio_out_request: fidl::endpoints::ServerEnd<AudioRendererMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Creates an AudioCapturer according to the given requirements.
    ///
    /// `pcm_stream_type` sets the stream type of the stream to be delivered.
    /// It causes the source material to be reformatted/resampled if needed
    /// in order to produce the requested stream type.
    ///
    /// `usage` is used by Fuchsia to make decisions about user experience.
    /// See `AudioCaptureUsage` for more details.
    ///
    /// `configuration` must be initialized to a variant, or no capturer
    /// can be created.
    CreateAudioCapturerWithConfiguration {
        stream_type: AudioStreamType,
        configuration: AudioCapturerConfiguration,
        audio_capturer_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Creates an AudioCapturer which either captures from the current default
    /// audio input device, or loops-back from the current default audio output
    /// device based on value passed for the loopback flag.
    CreateAudioCapturer {
        loopback: bool,
        audio_in_request: fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    SetRenderUsageGain {
        usage: AudioRenderUsage,
        gain_db: f32,
        control_handle: AudioCoreControlHandle,
    },
    /// Sets the gain for this render usage. By default, all render usages are set to Unity (0 db).
    SetRenderUsageGain2 {
        usage: AudioRenderUsage2,
        gain_db: f32,
        control_handle: AudioCoreControlHandle,
    },
    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    SetCaptureUsageGain {
        usage: AudioCaptureUsage,
        gain_db: f32,
        control_handle: AudioCoreControlHandle,
    },
    /// Sets gain for this capture usage. By default, all capture usages are set to Unity (0 db).
    SetCaptureUsageGain2 {
        usage: AudioCaptureUsage2,
        gain_db: f32,
        control_handle: AudioCoreControlHandle,
    },
    /// Binds to a volume control protocol for the given usage.
    BindUsageVolumeControl {
        usage: Usage,
        volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Binds to a volume control protocol for the given usage.
    BindUsageVolumeControl2 {
        usage: Usage2,
        volume_control: fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    GetVolumeFromDb { usage: Usage, gain_db: f32, responder: AudioCoreGetVolumeFromDbResponder },
    /// Queries the volume percentage [0, 1] that maps to a `gain_db` value for a particular
    /// `usage`. This is the same mapping as used by the VolumeControl from
    /// `BindUsageVolumeControl`.
    GetVolumeFromDb2 { usage: Usage2, gain_db: f32, responder: AudioCoreGetVolumeFromDb2Responder },
    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    GetDbFromVolume { usage: Usage, volume: f32, responder: AudioCoreGetDbFromVolumeResponder },
    /// Queries the decibel value that maps to a volume percentage [0, 1] for a particular `usage`.
    /// This is the same mapping as used by the VolumeControl from `BindUsageVolumeControl`.
    GetDbFromVolume2 { usage: Usage2, volume: f32, responder: AudioCoreGetDbFromVolume2Responder },
    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    SetInteraction {
        active: Usage,
        affected: Usage,
        behavior: Behavior,
        control_handle: AudioCoreControlHandle,
    },
    /// Sets how audio_core handles interactions of multiple active streams simultaneously. If
    /// streams of Usage `active` are processing audio, and streams of Usage `affected` are as well,
    /// the Behavior specified will be applied to the streams of Usage `affected`.
    SetInteraction2 {
        active: Usage2,
        affected: Usage2,
        behavior: Behavior,
        control_handle: AudioCoreControlHandle,
    },
    /// Re-initializes the set of rules that are currently governing the interaction of streams in
    /// audio_core. The default behavior is 'NONE'.
    ResetInteractions { control_handle: AudioCoreControlHandle },
    /// Re-loads the platform policy configuration. Falls back to a default config if the platform
    /// does not provide a config.
    LoadDefaults { control_handle: AudioCoreControlHandle },
    /// 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: AudioCoreControlHandle,
        method_type: fidl::MethodType,
    },
}

impl AudioCoreRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_renderer(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<AudioRendererMarker>, AudioCoreControlHandle)> {
        if let AudioCoreRequest::CreateAudioRenderer { audio_out_request, control_handle } = self {
            Some((audio_out_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_capturer_with_configuration(
        self,
    ) -> Option<(
        AudioStreamType,
        AudioCapturerConfiguration,
        fidl::endpoints::ServerEnd<AudioCapturerMarker>,
        AudioCoreControlHandle,
    )> {
        if let AudioCoreRequest::CreateAudioCapturerWithConfiguration {
            stream_type,
            configuration,
            audio_capturer_request,
            control_handle,
        } = self
        {
            Some((stream_type, configuration, audio_capturer_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_capturer(
        self,
    ) -> Option<(bool, fidl::endpoints::ServerEnd<AudioCapturerMarker>, AudioCoreControlHandle)>
    {
        if let AudioCoreRequest::CreateAudioCapturer {
            loopback,
            audio_in_request,
            control_handle,
        } = self
        {
            Some((loopback, audio_in_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_render_usage_gain(
        self,
    ) -> Option<(AudioRenderUsage, f32, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetRenderUsageGain { usage, gain_db, control_handle } = self {
            Some((usage, gain_db, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_render_usage_gain2(
        self,
    ) -> Option<(AudioRenderUsage2, f32, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetRenderUsageGain2 { usage, gain_db, control_handle } = self {
            Some((usage, gain_db, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_capture_usage_gain(
        self,
    ) -> Option<(AudioCaptureUsage, f32, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetCaptureUsageGain { usage, gain_db, control_handle } = self {
            Some((usage, gain_db, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_capture_usage_gain2(
        self,
    ) -> Option<(AudioCaptureUsage2, f32, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetCaptureUsageGain2 { usage, gain_db, control_handle } = self {
            Some((usage, gain_db, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_usage_volume_control(
        self,
    ) -> Option<(
        Usage,
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        AudioCoreControlHandle,
    )> {
        if let AudioCoreRequest::BindUsageVolumeControl { usage, volume_control, control_handle } =
            self
        {
            Some((usage, volume_control, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_usage_volume_control2(
        self,
    ) -> Option<(
        Usage2,
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
        AudioCoreControlHandle,
    )> {
        if let AudioCoreRequest::BindUsageVolumeControl2 { usage, volume_control, control_handle } =
            self
        {
            Some((usage, volume_control, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_volume_from_db(
        self,
    ) -> Option<(Usage, f32, AudioCoreGetVolumeFromDbResponder)> {
        if let AudioCoreRequest::GetVolumeFromDb { usage, gain_db, responder } = self {
            Some((usage, gain_db, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_volume_from_db2(
        self,
    ) -> Option<(Usage2, f32, AudioCoreGetVolumeFromDb2Responder)> {
        if let AudioCoreRequest::GetVolumeFromDb2 { usage, gain_db, responder } = self {
            Some((usage, gain_db, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_db_from_volume(
        self,
    ) -> Option<(Usage, f32, AudioCoreGetDbFromVolumeResponder)> {
        if let AudioCoreRequest::GetDbFromVolume { usage, volume, responder } = self {
            Some((usage, volume, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_db_from_volume2(
        self,
    ) -> Option<(Usage2, f32, AudioCoreGetDbFromVolume2Responder)> {
        if let AudioCoreRequest::GetDbFromVolume2 { usage, volume, responder } = self {
            Some((usage, volume, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_interaction(self) -> Option<(Usage, Usage, Behavior, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetInteraction { active, affected, behavior, control_handle } =
            self
        {
            Some((active, affected, behavior, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_interaction2(
        self,
    ) -> Option<(Usage2, Usage2, Behavior, AudioCoreControlHandle)> {
        if let AudioCoreRequest::SetInteraction2 { active, affected, behavior, control_handle } =
            self
        {
            Some((active, affected, behavior, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_interactions(self) -> Option<(AudioCoreControlHandle)> {
        if let AudioCoreRequest::ResetInteractions { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_load_defaults(self) -> Option<(AudioCoreControlHandle)> {
        if let AudioCoreRequest::LoadDefaults { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioCoreRequest::CreateAudioRenderer { .. } => "create_audio_renderer",
            AudioCoreRequest::CreateAudioCapturerWithConfiguration { .. } => {
                "create_audio_capturer_with_configuration"
            }
            AudioCoreRequest::CreateAudioCapturer { .. } => "create_audio_capturer",
            AudioCoreRequest::SetRenderUsageGain { .. } => "set_render_usage_gain",
            AudioCoreRequest::SetRenderUsageGain2 { .. } => "set_render_usage_gain2",
            AudioCoreRequest::SetCaptureUsageGain { .. } => "set_capture_usage_gain",
            AudioCoreRequest::SetCaptureUsageGain2 { .. } => "set_capture_usage_gain2",
            AudioCoreRequest::BindUsageVolumeControl { .. } => "bind_usage_volume_control",
            AudioCoreRequest::BindUsageVolumeControl2 { .. } => "bind_usage_volume_control2",
            AudioCoreRequest::GetVolumeFromDb { .. } => "get_volume_from_db",
            AudioCoreRequest::GetVolumeFromDb2 { .. } => "get_volume_from_db2",
            AudioCoreRequest::GetDbFromVolume { .. } => "get_db_from_volume",
            AudioCoreRequest::GetDbFromVolume2 { .. } => "get_db_from_volume2",
            AudioCoreRequest::SetInteraction { .. } => "set_interaction",
            AudioCoreRequest::SetInteraction2 { .. } => "set_interaction2",
            AudioCoreRequest::ResetInteractions { .. } => "reset_interactions",
            AudioCoreRequest::LoadDefaults { .. } => "load_defaults",
            AudioCoreRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            AudioCoreRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioCoreControlHandle {
    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 AudioCoreControlHandle {}

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

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

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

    fn send_raw(&self, mut volume: f32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioCoreGetVolumeFromDbResponse>(
            (volume,),
            self.tx_id,
            0x50e3ca45509770bf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut volume: f32) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<AudioCoreGetVolumeFromDb2Response>>(
                fidl::encoding::Flexible::new((volume,)),
                self.tx_id,
                0x165c811091ef99da,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(&self, mut gain_db: f32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioCoreGetDbFromVolumeResponse>(
            (gain_db,),
            self.tx_id,
            0x3e8eec27dd5a8bda,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut gain_db: f32) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<AudioCoreGetDbFromVolume2Response>>(
                fidl::encoding::Flexible::new((gain_db,)),
                self.tx_id,
                0x5f421a8ebf265bf3,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for AudioDeviceEnumeratorMarker {
    type Proxy = AudioDeviceEnumeratorProxy;
    type RequestStream = AudioDeviceEnumeratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioDeviceEnumeratorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.AudioDeviceEnumerator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioDeviceEnumeratorMarker {}

pub trait AudioDeviceEnumeratorProxyInterface: Send + Sync {
    type GetDevicesResponseFut: std::future::Future<Output = Result<Vec<AudioDeviceInfo>, fidl::Error>>
        + Send;
    fn r#get_devices(&self) -> Self::GetDevicesResponseFut;
    type GetDeviceGainResponseFut: std::future::Future<Output = Result<(u64, AudioGainInfo), fidl::Error>>
        + Send;
    fn r#get_device_gain(&self, device_token: u64) -> Self::GetDeviceGainResponseFut;
    fn r#set_device_gain(
        &self,
        device_token: u64,
        gain_info: &AudioGainInfo,
        valid_flags: AudioGainValidFlags,
    ) -> Result<(), fidl::Error>;
    fn r#add_device_by_channel(
        &self,
        device_name: &str,
        is_input: bool,
        channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioDeviceEnumeratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioDeviceEnumeratorSynchronousProxy {
    type Proxy = AudioDeviceEnumeratorProxy;
    type Protocol = AudioDeviceEnumeratorMarker;

    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 AudioDeviceEnumeratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AudioDeviceEnumeratorMarker 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<AudioDeviceEnumeratorEvent, fidl::Error> {
        AudioDeviceEnumeratorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Obtain the list of currently active audio devices.
    pub fn r#get_devices(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<AudioDeviceInfo>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioDeviceEnumeratorGetDevicesResponse>(
                (),
                0x4ce1aa218aeb12a6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.devices)
    }

    /// Gain/Mute/AGC control
    ///
    /// Note that each of these operations requires a device_token in order to
    /// target the proper input/output.
    ///
    /// The Get command returns the device_token of the device whose gain is
    /// being reported, or `ZX_KOID_INVALID` in the case that the requested
    /// device_token was invalid or the device had been removed from the system
    /// before the Get command could be processed.
    ///
    /// Set commands which are given an invalid device token are ignored and
    /// have no effect on the system. In addition, users do not need to control
    /// all of the gain settings for an audio device with each call. Only the
    /// settings with a corresponding flag set in the set_flags parameter will
    /// be affected. For example, passing SetAudioGainFlag_MuteValid will cause
    /// a SetDeviceGain call to care only about the mute setting in the
    /// gain_info structure, while passing (SetAudioGainFlag_GainValid |
    /// SetAudioGainFlag_MuteValid) will cause both the mute and the gain
    /// status to be changed simultaneously.
    pub fn r#get_device_gain(
        &self,
        mut device_token: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(u64, AudioGainInfo), fidl::Error> {
        let _response = self.client.send_query::<
            AudioDeviceEnumeratorGetDeviceGainRequest,
            AudioDeviceEnumeratorGetDeviceGainResponse,
        >(
            (device_token,),
            0x25dd4723403c414b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.device_token, _response.gain_info))
    }

    pub fn r#set_device_gain(
        &self,
        mut device_token: u64,
        mut gain_info: &AudioGainInfo,
        mut valid_flags: AudioGainValidFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioDeviceEnumeratorSetDeviceGainRequest>(
            (device_token, gain_info, valid_flags),
            0x5bdabc8ebe83591,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// # Deprecation
    ///
    /// StreamConfig is not supported anymore, instead use an
    /// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
    /// , see
    /// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
    pub fn r#add_device_by_channel(
        &self,
        mut device_name: &str,
        mut is_input: bool,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(
            (device_name, is_input, channel),
            0x72cdbada4d70ed67,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioDeviceEnumeratorProxy {
    type Protocol = AudioDeviceEnumeratorMarker;

    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 AudioDeviceEnumeratorProxy {
    /// Create a new Proxy for fuchsia.media/AudioDeviceEnumerator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AudioDeviceEnumeratorMarker 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) -> AudioDeviceEnumeratorEventStream {
        AudioDeviceEnumeratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Obtain the list of currently active audio devices.
    pub fn r#get_devices(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<AudioDeviceInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AudioDeviceEnumeratorProxyInterface::r#get_devices(self)
    }

    /// Gain/Mute/AGC control
    ///
    /// Note that each of these operations requires a device_token in order to
    /// target the proper input/output.
    ///
    /// The Get command returns the device_token of the device whose gain is
    /// being reported, or `ZX_KOID_INVALID` in the case that the requested
    /// device_token was invalid or the device had been removed from the system
    /// before the Get command could be processed.
    ///
    /// Set commands which are given an invalid device token are ignored and
    /// have no effect on the system. In addition, users do not need to control
    /// all of the gain settings for an audio device with each call. Only the
    /// settings with a corresponding flag set in the set_flags parameter will
    /// be affected. For example, passing SetAudioGainFlag_MuteValid will cause
    /// a SetDeviceGain call to care only about the mute setting in the
    /// gain_info structure, while passing (SetAudioGainFlag_GainValid |
    /// SetAudioGainFlag_MuteValid) will cause both the mute and the gain
    /// status to be changed simultaneously.
    pub fn r#get_device_gain(
        &self,
        mut device_token: u64,
    ) -> fidl::client::QueryResponseFut<
        (u64, AudioGainInfo),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AudioDeviceEnumeratorProxyInterface::r#get_device_gain(self, device_token)
    }

    pub fn r#set_device_gain(
        &self,
        mut device_token: u64,
        mut gain_info: &AudioGainInfo,
        mut valid_flags: AudioGainValidFlags,
    ) -> Result<(), fidl::Error> {
        AudioDeviceEnumeratorProxyInterface::r#set_device_gain(
            self,
            device_token,
            gain_info,
            valid_flags,
        )
    }

    /// # Deprecation
    ///
    /// StreamConfig is not supported anymore, instead use an
    /// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
    /// , see
    /// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
    pub fn r#add_device_by_channel(
        &self,
        mut device_name: &str,
        mut is_input: bool,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        AudioDeviceEnumeratorProxyInterface::r#add_device_by_channel(
            self,
            device_name,
            is_input,
            channel,
        )
    }
}

impl AudioDeviceEnumeratorProxyInterface for AudioDeviceEnumeratorProxy {
    type GetDevicesResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioDeviceInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_devices(&self) -> Self::GetDevicesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioDeviceInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioDeviceEnumeratorGetDevicesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4ce1aa218aeb12a6,
            >(_buf?)?;
            Ok(_response.devices)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<AudioDeviceInfo>>(
            (),
            0x4ce1aa218aeb12a6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetDeviceGainResponseFut = fidl::client::QueryResponseFut<
        (u64, AudioGainInfo),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_device_gain(&self, mut device_token: u64) -> Self::GetDeviceGainResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u64, AudioGainInfo), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioDeviceEnumeratorGetDeviceGainResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25dd4723403c414b,
            >(_buf?)?;
            Ok((_response.device_token, _response.gain_info))
        }
        self.client.send_query_and_decode::<
            AudioDeviceEnumeratorGetDeviceGainRequest,
            (u64, AudioGainInfo),
        >(
            (device_token,),
            0x25dd4723403c414b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_device_gain(
        &self,
        mut device_token: u64,
        mut gain_info: &AudioGainInfo,
        mut valid_flags: AudioGainValidFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioDeviceEnumeratorSetDeviceGainRequest>(
            (device_token, gain_info, valid_flags),
            0x5bdabc8ebe83591,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_device_by_channel(
        &self,
        mut device_name: &str,
        mut is_input: bool,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(
            (device_name, is_input, channel),
            0x72cdbada4d70ed67,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum AudioDeviceEnumeratorEvent {
    OnDeviceAdded { device: AudioDeviceInfo },
    OnDeviceRemoved { device_token: u64 },
    OnDeviceGainChanged { device_token: u64, gain_info: AudioGainInfo },
    OnDefaultDeviceChanged { old_default_token: u64, new_default_token: u64 },
}

impl AudioDeviceEnumeratorEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_device_added(self) -> Option<AudioDeviceInfo> {
        if let AudioDeviceEnumeratorEvent::OnDeviceAdded { device } = self {
            Some((device))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_device_removed(self) -> Option<u64> {
        if let AudioDeviceEnumeratorEvent::OnDeviceRemoved { device_token } = self {
            Some((device_token))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_device_gain_changed(self) -> Option<(u64, AudioGainInfo)> {
        if let AudioDeviceEnumeratorEvent::OnDeviceGainChanged { device_token, gain_info } = self {
            Some((device_token, gain_info))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_default_device_changed(self) -> Option<(u64, u64)> {
        if let AudioDeviceEnumeratorEvent::OnDefaultDeviceChanged {
            old_default_token,
            new_default_token,
        } = self
        {
            Some((old_default_token, new_default_token))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`AudioDeviceEnumeratorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AudioDeviceEnumeratorEvent, 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 {
            0xe0fbe40057c4b44 => {
                let mut out = fidl::new_empty!(
                    AudioDeviceEnumeratorOnDeviceAddedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorOnDeviceAddedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioDeviceEnumeratorEvent::OnDeviceAdded { device: out.device }))
            }
            0x6f3b7574463d9ff8 => {
                let mut out = fidl::new_empty!(
                    AudioDeviceEnumeratorOnDeviceRemovedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioDeviceEnumeratorEvent::OnDeviceRemoved { device_token: out.device_token }))
            }
            0x14aefcbbb076b0e9 => {
                let mut out = fidl::new_empty!(
                    AudioDeviceEnumeratorOnDeviceGainChangedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioDeviceEnumeratorEvent::OnDeviceGainChanged {
                    device_token: out.device_token,
                    gain_info: out.gain_info,
                }))
            }
            0x16357b42d4c16e11 => {
                let mut out = fidl::new_empty!(
                    AudioDeviceEnumeratorOnDefaultDeviceChangedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((AudioDeviceEnumeratorEvent::OnDefaultDeviceChanged {
                    old_default_token: out.old_default_token,
                    new_default_token: out.new_default_token,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <AudioDeviceEnumeratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for AudioDeviceEnumeratorRequestStream {
    type Protocol = AudioDeviceEnumeratorMarker;
    type ControlHandle = AudioDeviceEnumeratorControlHandle;

    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 {
        AudioDeviceEnumeratorControlHandle { 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 AudioDeviceEnumeratorRequestStream {
    type Item = Result<AudioDeviceEnumeratorRequest, 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 AudioDeviceEnumeratorRequestStream 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 {
                0x4ce1aa218aeb12a6 => {
                    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 = AudioDeviceEnumeratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AudioDeviceEnumeratorRequest::GetDevices {
                        responder: AudioDeviceEnumeratorGetDevicesResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x25dd4723403c414b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AudioDeviceEnumeratorGetDeviceGainRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorGetDeviceGainRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AudioDeviceEnumeratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AudioDeviceEnumeratorRequest::GetDeviceGain {device_token: req.device_token,

                        responder: AudioDeviceEnumeratorGetDeviceGainResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5bdabc8ebe83591 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AudioDeviceEnumeratorSetDeviceGainRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorSetDeviceGainRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AudioDeviceEnumeratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AudioDeviceEnumeratorRequest::SetDeviceGain {device_token: req.device_token,
gain_info: req.gain_info,
valid_flags: req.valid_flags,

                        control_handle,
                    })
                }
                0x72cdbada4d70ed67 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AudioDeviceEnumeratorAddDeviceByChannelRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AudioDeviceEnumeratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AudioDeviceEnumeratorRequest::AddDeviceByChannel {device_name: req.device_name,
is_input: req.is_input,
channel: req.channel,

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

#[derive(Debug)]
pub enum AudioDeviceEnumeratorRequest {
    /// Obtain the list of currently active audio devices.
    GetDevices { responder: AudioDeviceEnumeratorGetDevicesResponder },
    /// Gain/Mute/AGC control
    ///
    /// Note that each of these operations requires a device_token in order to
    /// target the proper input/output.
    ///
    /// The Get command returns the device_token of the device whose gain is
    /// being reported, or `ZX_KOID_INVALID` in the case that the requested
    /// device_token was invalid or the device had been removed from the system
    /// before the Get command could be processed.
    ///
    /// Set commands which are given an invalid device token are ignored and
    /// have no effect on the system. In addition, users do not need to control
    /// all of the gain settings for an audio device with each call. Only the
    /// settings with a corresponding flag set in the set_flags parameter will
    /// be affected. For example, passing SetAudioGainFlag_MuteValid will cause
    /// a SetDeviceGain call to care only about the mute setting in the
    /// gain_info structure, while passing (SetAudioGainFlag_GainValid |
    /// SetAudioGainFlag_MuteValid) will cause both the mute and the gain
    /// status to be changed simultaneously.
    GetDeviceGain { device_token: u64, responder: AudioDeviceEnumeratorGetDeviceGainResponder },
    SetDeviceGain {
        device_token: u64,
        gain_info: AudioGainInfo,
        valid_flags: AudioGainValidFlags,
        control_handle: AudioDeviceEnumeratorControlHandle,
    },
    /// # Deprecation
    ///
    /// StreamConfig is not supported anymore, instead use an
    /// [Audio Composite](https://fuchsia.dev/fuchsia-src/development/audio/drivers/composite)
    /// , see
    /// [Audio Drivers Architecture](https://fuchsia.dev/fuchsia-src/development/audio/drivers/architecture)
    AddDeviceByChannel {
        device_name: String,
        is_input: bool,
        channel: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
        control_handle: AudioDeviceEnumeratorControlHandle,
    },
}

impl AudioDeviceEnumeratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_devices(self) -> Option<(AudioDeviceEnumeratorGetDevicesResponder)> {
        if let AudioDeviceEnumeratorRequest::GetDevices { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_device_gain(
        self,
    ) -> Option<(u64, AudioDeviceEnumeratorGetDeviceGainResponder)> {
        if let AudioDeviceEnumeratorRequest::GetDeviceGain { device_token, responder } = self {
            Some((device_token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_device_gain(
        self,
    ) -> Option<(u64, AudioGainInfo, AudioGainValidFlags, AudioDeviceEnumeratorControlHandle)> {
        if let AudioDeviceEnumeratorRequest::SetDeviceGain {
            device_token,
            gain_info,
            valid_flags,
            control_handle,
        } = self
        {
            Some((device_token, gain_info, valid_flags, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_device_by_channel(
        self,
    ) -> Option<(
        String,
        bool,
        fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
        AudioDeviceEnumeratorControlHandle,
    )> {
        if let AudioDeviceEnumeratorRequest::AddDeviceByChannel {
            device_name,
            is_input,
            channel,
            control_handle,
        } = self
        {
            Some((device_name, is_input, channel, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioDeviceEnumeratorRequest::GetDevices { .. } => "get_devices",
            AudioDeviceEnumeratorRequest::GetDeviceGain { .. } => "get_device_gain",
            AudioDeviceEnumeratorRequest::SetDeviceGain { .. } => "set_device_gain",
            AudioDeviceEnumeratorRequest::AddDeviceByChannel { .. } => "add_device_by_channel",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioDeviceEnumeratorControlHandle {
    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 AudioDeviceEnumeratorControlHandle {
    pub fn send_on_device_added(&self, mut device: &AudioDeviceInfo) -> Result<(), fidl::Error> {
        self.inner.send::<AudioDeviceEnumeratorOnDeviceAddedRequest>(
            (device,),
            0,
            0xe0fbe40057c4b44,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_device_removed(&self, mut device_token: u64) -> Result<(), fidl::Error> {
        self.inner.send::<AudioDeviceEnumeratorOnDeviceRemovedRequest>(
            (device_token,),
            0,
            0x6f3b7574463d9ff8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_device_gain_changed(
        &self,
        mut device_token: u64,
        mut gain_info: &AudioGainInfo,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<AudioDeviceEnumeratorOnDeviceGainChangedRequest>(
            (device_token, gain_info),
            0,
            0x14aefcbbb076b0e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_default_device_changed(
        &self,
        mut old_default_token: u64,
        mut new_default_token: u64,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<AudioDeviceEnumeratorOnDefaultDeviceChangedRequest>(
            (old_default_token, new_default_token),
            0,
            0x16357b42d4c16e11,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut devices: &[AudioDeviceInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioDeviceEnumeratorGetDevicesResponse>(
            (devices,),
            self.tx_id,
            0x4ce1aa218aeb12a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut device_token: u64,
        mut gain_info: &AudioGainInfo,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioDeviceEnumeratorGetDeviceGainResponse>(
            (device_token, gain_info),
            self.tx_id,
            0x25dd4723403c414b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for AudioRendererMarker {
    type Proxy = AudioRendererProxy;
    type RequestStream = AudioRendererRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AudioRendererSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.AudioRenderer";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AudioRendererMarker {}

pub trait AudioRendererProxyInterface: Send + Sync {
    fn r#add_payload_buffer(&self, id: u32, payload_buffer: fidl::Vmo) -> Result<(), fidl::Error>;
    fn r#remove_payload_buffer(&self, id: u32) -> Result<(), fidl::Error>;
    type SendPacketResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#send_packet(&self, packet: &StreamPacket) -> Self::SendPacketResponseFut;
    fn r#send_packet_no_reply(&self, packet: &StreamPacket) -> Result<(), fidl::Error>;
    fn r#end_of_stream(&self) -> Result<(), fidl::Error>;
    type DiscardAllPacketsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut;
    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error>;
    fn r#bind_gain_control(
        &self,
        gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    fn r#set_pts_units(
        &self,
        tick_per_second_numerator: u32,
        tick_per_second_denominator: u32,
    ) -> Result<(), fidl::Error>;
    fn r#set_pts_continuity_threshold(&self, threshold_seconds: f32) -> Result<(), fidl::Error>;
    type GetReferenceClockResponseFut: std::future::Future<Output = Result<fidl::Clock, fidl::Error>>
        + Send;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut;
    fn r#set_reference_clock(
        &self,
        reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error>;
    fn r#set_usage(&self, usage: AudioRenderUsage) -> Result<(), fidl::Error>;
    fn r#set_usage2(&self, usage2: AudioRenderUsage2) -> Result<(), fidl::Error>;
    fn r#set_pcm_stream_type(&self, type_: &AudioStreamType) -> Result<(), fidl::Error>;
    fn r#enable_min_lead_time_events(&self, enabled: bool) -> Result<(), fidl::Error>;
    type GetMinLeadTimeResponseFut: std::future::Future<Output = Result<i64, fidl::Error>> + Send;
    fn r#get_min_lead_time(&self) -> Self::GetMinLeadTimeResponseFut;
    type PlayResponseFut: std::future::Future<Output = Result<(i64, i64), fidl::Error>> + Send;
    fn r#play(&self, reference_time: i64, media_time: i64) -> Self::PlayResponseFut;
    fn r#play_no_reply(&self, reference_time: i64, media_time: i64) -> Result<(), fidl::Error>;
    type PauseResponseFut: std::future::Future<Output = Result<(i64, i64), fidl::Error>> + Send;
    fn r#pause(&self) -> Self::PauseResponseFut;
    fn r#pause_no_reply(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AudioRendererSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AudioRendererSynchronousProxy {
    type Proxy = AudioRendererProxy;
    type Protocol = AudioRendererMarker;

    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 AudioRendererSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AudioRendererMarker 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<AudioRendererEvent, fidl::Error> {
        AudioRendererEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<StreamSinkSendPacketRequest, fidl::encoding::EmptyPayload>(
                (packet,),
                0x67cddd607442775f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x6f4dad7af2917665,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Binds to the gain control for this AudioRenderer.
    pub fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererBindGainControlRequest>(
            (gain_control_request,),
            0x293f5c7f8fba2bdc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the units used by the presentation (media) timeline. By default, PTS units are
    /// nanoseconds (as if this were called with numerator of 1e9 and denominator of 1).
    /// This ratio must lie between 1/60 (1 tick per minute) and 1e9/1 (1ns per tick).
    pub fn r#set_pts_units(
        &self,
        mut tick_per_second_numerator: u32,
        mut tick_per_second_denominator: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPtsUnitsRequest>(
            (tick_per_second_numerator, tick_per_second_denominator),
            0xf68cd108785a27c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the maximum threshold (in seconds) between explicit user-provided PTS
    /// and expected PTS (determined using interpolation). Beyond this threshold,
    /// a stream is no longer considered 'continuous' by the renderer.
    ///
    /// Defaults to an interval of half a PTS 'tick', using the currently-defined PTS units.
    /// Most users should not need to change this value from its default.
    ///
    /// Example:
    /// A user is playing back 48KHz audio from a container, which also contains
    /// video and needs to be synchronized with the audio. The timestamps are
    /// provided explicitly per packet by the container, and expressed in mSec
    /// units. This means that a single tick of the media timeline (1 mSec)
    /// represents exactly 48 frames of audio. The application in this scenario
    /// delivers packets of audio to the AudioRenderer, each with exactly 470
    /// frames of audio, and each with an explicit timestamp set to the best
    /// possible representation of the presentation time (given this media
    /// clock's resolution). So, starting from zero, the timestamps would be..
    ///
    /// [ 0, 10, 20, 29, 39, 49, 59, 69, 78, 88, ... ]
    ///
    /// In this example, attempting to use the presentation time to compute the
    /// starting frame number of the audio in the packet would be wrong the
    /// majority of the time. The first timestamp is correct (by definition), but
    /// it will be 24 packets before the timestamps and frame numbers come back
    /// into alignment (the 24th packet would start with the 11280th audio frame
    /// and have a PTS of exactly 235).
    ///
    /// One way to fix this situation is to set the PTS continuity threshold
    /// (henceforth, CT) for the stream to be equal to 1/2 of the time taken by
    /// the number of frames contained within a single tick of the media clock,
    /// rounded up. In this scenario, that would be 24.0 frames of audio, or 500
    /// uSec. Any packets whose expected PTS was within +/-CT frames of the
    /// explicitly provided PTS would be considered to be a continuation of the
    /// previous frame of audio. For this example, calling 'SetPtsContinuityThreshold(0.0005)'
    /// would work well.
    ///
    /// Other possible uses:
    /// Users who are scheduling audio explicitly, relative to a clock which has
    /// not been configured as the reference clock, can use this value to control
    /// the maximum acceptable synchronization error before a discontinuity is
    /// introduced. E.g., if a user is scheduling audio based on a recovered
    /// common media clock, and has not published that clock as the reference
    /// clock, and they set the CT to 20mSec, then up to 20mSec of drift error
    /// can accumulate before the AudioRenderer deliberately inserts a
    /// presentation discontinuity to account for the error.
    ///
    /// Users whose need to deal with a container where their timestamps may be
    /// even less correct than +/- 1/2 of a PTS tick may set this value to
    /// something larger. This should be the maximum level of inaccuracy present
    /// in the container timestamps, if known. Failing that, it could be set to
    /// the maximum tolerable level of drift error before absolute timestamps are
    /// explicitly obeyed. Finally, a user could set this number to a very large
    /// value (86400.0 seconds, for example) to effectively cause *all*
    /// timestamps to be ignored after the first, thus treating all audio as
    /// continuous with previously delivered packets. Conversely, users who wish
    /// to *always* explicitly schedule their audio packets exactly may specify
    /// a CT of 0.
    ///
    /// Note: explicitly specifying high-frequency PTS units reduces the default
    /// continuity threshold accordingly. Internally, this threshold is stored as an
    /// integer of 1/8192 subframes. The default threshold is computed as follows:
    ///     RoundUp((AudioFPS/PTSTicksPerSec) * 4096) / (AudioFPS * 8192)
    /// For this reason, specifying PTS units with a frequency greater than 8192x
    /// the frame rate (or NOT calling SetPtsUnits, which accepts the default PTS
    /// unit of 1 nanosec) will result in a default continuity threshold of zero.
    pub fn r#set_pts_continuity_threshold(
        &self,
        mut threshold_seconds: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPtsContinuityThresholdRequest>(
            (threshold_seconds,),
            0x2849ba571d1971ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    pub fn r#get_reference_clock(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Clock, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioRendererGetReferenceClockResponse>(
                (),
                0x2f7a7f011a172f7e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.reference_clock)
    }

    /// Sets the reference clock that controls this renderer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called once `SetPcmStreamType` is called. It also
    /// cannot be called a second time (even if the renderer format has not yet been set).
    /// If a client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    pub fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetReferenceClockRequest>(
            (reference_clock,),
            0x39acd05d832b5fed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    pub fn r#set_usage(&self, mut usage: AudioRenderUsage) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetUsageRequest>(
            (usage,),
            0x3994bd23b55a733e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    pub fn r#set_usage2(&self, mut usage2: AudioRenderUsage2) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetUsage2Request>(
            (usage2,),
            0x2904035c7132b103,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Sets the type of the stream to be delivered by the client. Using this method implies
    /// that the stream encoding is `AUDIO_ENCODING_LPCM`.
    ///
    /// This must be called before `Play` or `PlayNoReply`. After a call to `SetPcmStreamType`,
    /// the client must then send an `AddPayloadBuffer` request, then the various `StreamSink`
    /// methods such as `SendPacket`/`SendPacketNoReply`.
    pub fn r#set_pcm_stream_type(&self, mut type_: &AudioStreamType) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPcmStreamTypeRequest>(
            (type_,),
            0x27aa715d8901fa19,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Enables or disables notifications about changes to the minimum clock lead
    /// time (in nanoseconds) for this AudioRenderer. Calling this method with
    /// 'enabled' set to true will trigger an immediate `OnMinLeadTimeChanged`
    /// event with the current minimum lead time for the AudioRenderer. If the
    /// value changes, an `OnMinLeadTimeChanged` event will be raised with the
    /// new value. This behavior will continue until the user calls
    /// `EnableMinLeadTimeEvents(false)`.
    ///
    /// The minimum clock lead time is the amount of time ahead of the reference
    /// clock's understanding of "now" that packets needs to arrive (relative to
    /// the playback clock transformation) in order for the mixer to be able to
    /// mix packet. For example...
    ///
    /// + Let the PTS of packet X be P(X)
    /// + Let the function which transforms PTS -> RefClock be R(p) (this
    ///   function is determined by the call to Play(...)
    /// + Let the minimum lead time be MLT
    ///
    /// If R(P(X)) < RefClock.Now() + MLT
    /// Then the packet is late, and some (or all) of the packet's payload will
    /// need to be skipped in order to present the packet at the scheduled time.
    ///
    /// The value `min_lead_time_nsec = 0` is a special value which indicates
    /// that the AudioRenderer is not yet routed to an output device. If `Play`
    /// is called before the AudioRenderer is routed, any played packets will be
    /// dropped. Clients should wait until `min_lead_time_nsec > 0` before
    /// calling `Play`.
    pub fn r#enable_min_lead_time_events(&self, mut enabled: bool) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererEnableMinLeadTimeEventsRequest>(
            (enabled,),
            0x62808dfad72bf890,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    ///
    /// While it is possible to call `GetMinLeadTime` before `SetPcmStreamType`,
    /// there's little reason to do so. This is because lead time is a function
    /// of format/rate, so lead time will be recalculated after `SetPcmStreamType`.
    /// If min lead time events are enabled before `SetPcmStreamType` (with
    /// `EnableMinLeadTimeEvents(true)`), then an event will be generated in
    /// response to `SetPcmStreamType`.
    pub fn r#get_min_lead_time(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i64, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AudioRendererGetMinLeadTimeResponse>(
                (),
                0x1cf3c3ecd8fec26b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.min_lead_time_nsec)
    }

    /// Immediately puts the AudioRenderer into a playing state. Starts the advance
    /// of the media timeline, using specific values provided by the caller (or
    /// default values if not specified). In an optional callback, returns the
    /// timestamp values ultimately used -- these set the ongoing relationship
    /// between the media and reference timelines (i.e., how to translate between
    /// the domain of presentation timestamps, and the realm of local system
    /// time).
    ///
    /// Local system time is specified in units of nanoseconds; media_time is
    /// specified in the units defined by the user in the `SetPtsUnits` function,
    /// or nanoseconds if `SetPtsUnits` is not called.
    ///
    /// The act of placing an AudioRenderer into the playback state establishes a
    /// relationship between 1) the user-defined media (or presentation) timeline
    /// for this particular AudioRenderer, and 2) the real-world system reference
    /// timeline. To communicate how to translate between timelines, the Play()
    /// callback provides an equivalent timestamp in each time domain. The first
    /// value ('reference_time') is given in terms of this renderer's reference
    /// clock; the second value ('media_time') is what media instant exactly
    /// corresponds to that local time. Restated, the frame at 'media_time' in
    /// the audio stream should be presented at 'reference_time' according to
    /// the reference clock.
    ///
    /// Note: on calling this API, media_time immediately starts advancing. It is
    /// possible (if uncommon) for a caller to specify a system time that is
    /// far in the past, or far into the future. This, along with the specified
    /// media time, is simply used to determine what media time corresponds to
    /// 'now', and THAT media time is then intersected with presentation
    /// timestamps of packets already submitted, to determine which media frames
    /// should be presented next.
    ///
    /// With the corresponding reference_time and media_time values, a user can
    /// translate arbitrary time values from one timeline into the other. After
    /// calling `SetPtsUnits(pts_per_sec_numerator, pts_per_sec_denominator)` and
    /// given the 'ref_start' and 'media_start' values from `Play`, then for
    /// any 'ref_time':
    ///
    /// media_time = ( (ref_time - ref_start) / 1e9
    ///                * (pts_per_sec_numerator / pts_per_sec_denominator) )
    ///              + media_start
    ///
    /// Conversely, for any presentation timestamp 'media_time':
    ///
    /// ref_time = ( (media_time - media_start)
    ///              * (pts_per_sec_denominator / pts_per_sec_numerator)
    ///              * 1e9 )
    ///            + ref_start
    ///
    /// Users, depending on their use case, may optionally choose not to specify
    /// one or both of these timestamps. A timestamp may be omitted by supplying
    /// the special value '`NO_TIMESTAMP`'. The AudioRenderer automatically deduces
    /// any omitted timestamp value using the following rules:
    ///
    /// Reference Time
    /// If 'reference_time' is omitted, the AudioRenderer will select a "safe"
    /// reference time to begin presentation, based on the minimum lead times for
    /// the output devices that are currently bound to this AudioRenderer. For
    /// example, if an AudioRenderer is bound to an internal audio output
    /// requiring at least 3 mSec of lead time, and an HDMI output requiring at
    /// least 75 mSec of lead time, the AudioRenderer might (if 'reference_time'
    /// is omitted) select a reference time 80 mSec from now.
    ///
    /// Media Time
    /// If media_time is omitted, the AudioRenderer will select one of two
    /// values.
    /// - If the AudioRenderer is resuming from the paused state, and packets
    /// have not been discarded since being paused, then the AudioRenderer will
    /// use a media_time corresponding to the instant at which the presentation
    /// became paused.
    /// - If the AudioRenderer is being placed into a playing state for the first
    /// time following startup or a 'discard packets' operation, the initial
    /// media_time will be set to the PTS of the first payload in the pending
    /// packet queue. If the pending queue is empty, initial media_time will be
    /// set to zero.
    ///
    /// Return Value
    /// When requested, the AudioRenderer will return the 'reference_time' and
    /// 'media_time' which were selected and used (whether they were explicitly
    /// specified or not) in the return value of the play call.
    ///
    /// Examples
    /// 1. A user has queued some audio using `SendPacket` and simply wishes them
    /// to start playing as soon as possible. The user may call Play without
    /// providing explicit timestamps -- `Play(NO_TIMESTAMP, NO_TIMESTAMP)`.
    ///
    /// 2. A user has queued some audio using `SendPacket`, and wishes to start
    /// playback at a specified 'reference_time', in sync with some other media
    /// stream, either initially or after discarding packets. The user would call
    /// `Play(reference_time, NO_TIMESTAMP)`.
    ///
    /// 3. A user has queued some audio using `SendPacket`. The first of these
    /// packets has a PTS of zero, and the user wishes playback to begin as soon
    /// as possible, but wishes to skip all of the audio content between PTS 0
    /// and PTS 'media_time'. The user would call
    /// `Play(NO_TIMESTAMP, media_time)`.
    ///
    /// 4. A user has queued some audio using `SendPacket` and want to present
    /// this media in synch with another player in a different device. The
    /// coordinator of the group of distributed players sends an explicit
    /// message to each player telling them to begin presentation of audio at
    /// PTS 'media_time', at the time (based on the group's shared reference
    /// clock) 'reference_time'. Here the user would call
    /// `Play(reference_time, media_time)`.
    pub fn r#play(
        &self,
        mut reference_time: i64,
        mut media_time: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i64, i64), fidl::Error> {
        let _response =
            self.client.send_query::<AudioRendererPlayRequest, AudioRendererPlayResponse>(
                (reference_time, media_time),
                0x3c0162db084f74a3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.reference_time, _response.media_time))
    }

    pub fn r#play_no_reply(
        &self,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererPlayNoReplyRequest>(
            (reference_time, media_time),
            0x1b7fe832b68c22ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Immediately puts the AudioRenderer into the paused state and then report
    /// the relationship between the media and reference timelines which was
    /// established (if requested).
    ///
    /// If the AudioRenderer is already in the paused state when this called,
    /// the previously-established timeline values are returned (if requested).
    pub fn r#pause(&self, ___deadline: zx::MonotonicInstant) -> Result<(i64, i64), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, AudioRendererPauseResponse>(
                (),
                0x41d557588d93d153,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.reference_time, _response.media_time))
    }

    pub fn r#pause_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x24cc45d4f3855ab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AudioRendererProxy {
    type Protocol = AudioRendererMarker;

    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 AudioRendererProxy {
    /// Create a new Proxy for fuchsia.media/AudioRenderer.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AudioRendererMarker 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) -> AudioRendererEventStream {
        AudioRendererEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#add_payload_buffer(self, id, payload_buffer)
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#remove_payload_buffer(self, id)
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioRendererProxyInterface::r#send_packet(self, packet)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#send_packet_no_reply(self, packet)
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#end_of_stream(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioRendererProxyInterface::r#discard_all_packets(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#discard_all_packets_no_reply(self)
    }

    /// Binds to the gain control for this AudioRenderer.
    pub fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#bind_gain_control(self, gain_control_request)
    }

    /// Sets the units used by the presentation (media) timeline. By default, PTS units are
    /// nanoseconds (as if this were called with numerator of 1e9 and denominator of 1).
    /// This ratio must lie between 1/60 (1 tick per minute) and 1e9/1 (1ns per tick).
    pub fn r#set_pts_units(
        &self,
        mut tick_per_second_numerator: u32,
        mut tick_per_second_denominator: u32,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_pts_units(
            self,
            tick_per_second_numerator,
            tick_per_second_denominator,
        )
    }

    /// Sets the maximum threshold (in seconds) between explicit user-provided PTS
    /// and expected PTS (determined using interpolation). Beyond this threshold,
    /// a stream is no longer considered 'continuous' by the renderer.
    ///
    /// Defaults to an interval of half a PTS 'tick', using the currently-defined PTS units.
    /// Most users should not need to change this value from its default.
    ///
    /// Example:
    /// A user is playing back 48KHz audio from a container, which also contains
    /// video and needs to be synchronized with the audio. The timestamps are
    /// provided explicitly per packet by the container, and expressed in mSec
    /// units. This means that a single tick of the media timeline (1 mSec)
    /// represents exactly 48 frames of audio. The application in this scenario
    /// delivers packets of audio to the AudioRenderer, each with exactly 470
    /// frames of audio, and each with an explicit timestamp set to the best
    /// possible representation of the presentation time (given this media
    /// clock's resolution). So, starting from zero, the timestamps would be..
    ///
    /// [ 0, 10, 20, 29, 39, 49, 59, 69, 78, 88, ... ]
    ///
    /// In this example, attempting to use the presentation time to compute the
    /// starting frame number of the audio in the packet would be wrong the
    /// majority of the time. The first timestamp is correct (by definition), but
    /// it will be 24 packets before the timestamps and frame numbers come back
    /// into alignment (the 24th packet would start with the 11280th audio frame
    /// and have a PTS of exactly 235).
    ///
    /// One way to fix this situation is to set the PTS continuity threshold
    /// (henceforth, CT) for the stream to be equal to 1/2 of the time taken by
    /// the number of frames contained within a single tick of the media clock,
    /// rounded up. In this scenario, that would be 24.0 frames of audio, or 500
    /// uSec. Any packets whose expected PTS was within +/-CT frames of the
    /// explicitly provided PTS would be considered to be a continuation of the
    /// previous frame of audio. For this example, calling 'SetPtsContinuityThreshold(0.0005)'
    /// would work well.
    ///
    /// Other possible uses:
    /// Users who are scheduling audio explicitly, relative to a clock which has
    /// not been configured as the reference clock, can use this value to control
    /// the maximum acceptable synchronization error before a discontinuity is
    /// introduced. E.g., if a user is scheduling audio based on a recovered
    /// common media clock, and has not published that clock as the reference
    /// clock, and they set the CT to 20mSec, then up to 20mSec of drift error
    /// can accumulate before the AudioRenderer deliberately inserts a
    /// presentation discontinuity to account for the error.
    ///
    /// Users whose need to deal with a container where their timestamps may be
    /// even less correct than +/- 1/2 of a PTS tick may set this value to
    /// something larger. This should be the maximum level of inaccuracy present
    /// in the container timestamps, if known. Failing that, it could be set to
    /// the maximum tolerable level of drift error before absolute timestamps are
    /// explicitly obeyed. Finally, a user could set this number to a very large
    /// value (86400.0 seconds, for example) to effectively cause *all*
    /// timestamps to be ignored after the first, thus treating all audio as
    /// continuous with previously delivered packets. Conversely, users who wish
    /// to *always* explicitly schedule their audio packets exactly may specify
    /// a CT of 0.
    ///
    /// Note: explicitly specifying high-frequency PTS units reduces the default
    /// continuity threshold accordingly. Internally, this threshold is stored as an
    /// integer of 1/8192 subframes. The default threshold is computed as follows:
    ///     RoundUp((AudioFPS/PTSTicksPerSec) * 4096) / (AudioFPS * 8192)
    /// For this reason, specifying PTS units with a frequency greater than 8192x
    /// the frame rate (or NOT calling SetPtsUnits, which accepts the default PTS
    /// unit of 1 nanosec) will result in a default continuity threshold of zero.
    pub fn r#set_pts_continuity_threshold(
        &self,
        mut threshold_seconds: f32,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_pts_continuity_threshold(self, threshold_seconds)
    }

    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    pub fn r#get_reference_clock(
        &self,
    ) -> fidl::client::QueryResponseFut<fidl::Clock, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioRendererProxyInterface::r#get_reference_clock(self)
    }

    /// Sets the reference clock that controls this renderer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called once `SetPcmStreamType` is called. It also
    /// cannot be called a second time (even if the renderer format has not yet been set).
    /// If a client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    pub fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_reference_clock(self, reference_clock)
    }

    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    pub fn r#set_usage(&self, mut usage: AudioRenderUsage) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_usage(self, usage)
    }

    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    pub fn r#set_usage2(&self, mut usage2: AudioRenderUsage2) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_usage2(self, usage2)
    }

    /// Sets the type of the stream to be delivered by the client. Using this method implies
    /// that the stream encoding is `AUDIO_ENCODING_LPCM`.
    ///
    /// This must be called before `Play` or `PlayNoReply`. After a call to `SetPcmStreamType`,
    /// the client must then send an `AddPayloadBuffer` request, then the various `StreamSink`
    /// methods such as `SendPacket`/`SendPacketNoReply`.
    pub fn r#set_pcm_stream_type(&self, mut type_: &AudioStreamType) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#set_pcm_stream_type(self, type_)
    }

    /// Enables or disables notifications about changes to the minimum clock lead
    /// time (in nanoseconds) for this AudioRenderer. Calling this method with
    /// 'enabled' set to true will trigger an immediate `OnMinLeadTimeChanged`
    /// event with the current minimum lead time for the AudioRenderer. If the
    /// value changes, an `OnMinLeadTimeChanged` event will be raised with the
    /// new value. This behavior will continue until the user calls
    /// `EnableMinLeadTimeEvents(false)`.
    ///
    /// The minimum clock lead time is the amount of time ahead of the reference
    /// clock's understanding of "now" that packets needs to arrive (relative to
    /// the playback clock transformation) in order for the mixer to be able to
    /// mix packet. For example...
    ///
    /// + Let the PTS of packet X be P(X)
    /// + Let the function which transforms PTS -> RefClock be R(p) (this
    ///   function is determined by the call to Play(...)
    /// + Let the minimum lead time be MLT
    ///
    /// If R(P(X)) < RefClock.Now() + MLT
    /// Then the packet is late, and some (or all) of the packet's payload will
    /// need to be skipped in order to present the packet at the scheduled time.
    ///
    /// The value `min_lead_time_nsec = 0` is a special value which indicates
    /// that the AudioRenderer is not yet routed to an output device. If `Play`
    /// is called before the AudioRenderer is routed, any played packets will be
    /// dropped. Clients should wait until `min_lead_time_nsec > 0` before
    /// calling `Play`.
    pub fn r#enable_min_lead_time_events(&self, mut enabled: bool) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#enable_min_lead_time_events(self, enabled)
    }

    ///
    /// While it is possible to call `GetMinLeadTime` before `SetPcmStreamType`,
    /// there's little reason to do so. This is because lead time is a function
    /// of format/rate, so lead time will be recalculated after `SetPcmStreamType`.
    /// If min lead time events are enabled before `SetPcmStreamType` (with
    /// `EnableMinLeadTimeEvents(true)`), then an event will be generated in
    /// response to `SetPcmStreamType`.
    pub fn r#get_min_lead_time(
        &self,
    ) -> fidl::client::QueryResponseFut<i64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        AudioRendererProxyInterface::r#get_min_lead_time(self)
    }

    /// Immediately puts the AudioRenderer into a playing state. Starts the advance
    /// of the media timeline, using specific values provided by the caller (or
    /// default values if not specified). In an optional callback, returns the
    /// timestamp values ultimately used -- these set the ongoing relationship
    /// between the media and reference timelines (i.e., how to translate between
    /// the domain of presentation timestamps, and the realm of local system
    /// time).
    ///
    /// Local system time is specified in units of nanoseconds; media_time is
    /// specified in the units defined by the user in the `SetPtsUnits` function,
    /// or nanoseconds if `SetPtsUnits` is not called.
    ///
    /// The act of placing an AudioRenderer into the playback state establishes a
    /// relationship between 1) the user-defined media (or presentation) timeline
    /// for this particular AudioRenderer, and 2) the real-world system reference
    /// timeline. To communicate how to translate between timelines, the Play()
    /// callback provides an equivalent timestamp in each time domain. The first
    /// value ('reference_time') is given in terms of this renderer's reference
    /// clock; the second value ('media_time') is what media instant exactly
    /// corresponds to that local time. Restated, the frame at 'media_time' in
    /// the audio stream should be presented at 'reference_time' according to
    /// the reference clock.
    ///
    /// Note: on calling this API, media_time immediately starts advancing. It is
    /// possible (if uncommon) for a caller to specify a system time that is
    /// far in the past, or far into the future. This, along with the specified
    /// media time, is simply used to determine what media time corresponds to
    /// 'now', and THAT media time is then intersected with presentation
    /// timestamps of packets already submitted, to determine which media frames
    /// should be presented next.
    ///
    /// With the corresponding reference_time and media_time values, a user can
    /// translate arbitrary time values from one timeline into the other. After
    /// calling `SetPtsUnits(pts_per_sec_numerator, pts_per_sec_denominator)` and
    /// given the 'ref_start' and 'media_start' values from `Play`, then for
    /// any 'ref_time':
    ///
    /// media_time = ( (ref_time - ref_start) / 1e9
    ///                * (pts_per_sec_numerator / pts_per_sec_denominator) )
    ///              + media_start
    ///
    /// Conversely, for any presentation timestamp 'media_time':
    ///
    /// ref_time = ( (media_time - media_start)
    ///              * (pts_per_sec_denominator / pts_per_sec_numerator)
    ///              * 1e9 )
    ///            + ref_start
    ///
    /// Users, depending on their use case, may optionally choose not to specify
    /// one or both of these timestamps. A timestamp may be omitted by supplying
    /// the special value '`NO_TIMESTAMP`'. The AudioRenderer automatically deduces
    /// any omitted timestamp value using the following rules:
    ///
    /// Reference Time
    /// If 'reference_time' is omitted, the AudioRenderer will select a "safe"
    /// reference time to begin presentation, based on the minimum lead times for
    /// the output devices that are currently bound to this AudioRenderer. For
    /// example, if an AudioRenderer is bound to an internal audio output
    /// requiring at least 3 mSec of lead time, and an HDMI output requiring at
    /// least 75 mSec of lead time, the AudioRenderer might (if 'reference_time'
    /// is omitted) select a reference time 80 mSec from now.
    ///
    /// Media Time
    /// If media_time is omitted, the AudioRenderer will select one of two
    /// values.
    /// - If the AudioRenderer is resuming from the paused state, and packets
    /// have not been discarded since being paused, then the AudioRenderer will
    /// use a media_time corresponding to the instant at which the presentation
    /// became paused.
    /// - If the AudioRenderer is being placed into a playing state for the first
    /// time following startup or a 'discard packets' operation, the initial
    /// media_time will be set to the PTS of the first payload in the pending
    /// packet queue. If the pending queue is empty, initial media_time will be
    /// set to zero.
    ///
    /// Return Value
    /// When requested, the AudioRenderer will return the 'reference_time' and
    /// 'media_time' which were selected and used (whether they were explicitly
    /// specified or not) in the return value of the play call.
    ///
    /// Examples
    /// 1. A user has queued some audio using `SendPacket` and simply wishes them
    /// to start playing as soon as possible. The user may call Play without
    /// providing explicit timestamps -- `Play(NO_TIMESTAMP, NO_TIMESTAMP)`.
    ///
    /// 2. A user has queued some audio using `SendPacket`, and wishes to start
    /// playback at a specified 'reference_time', in sync with some other media
    /// stream, either initially or after discarding packets. The user would call
    /// `Play(reference_time, NO_TIMESTAMP)`.
    ///
    /// 3. A user has queued some audio using `SendPacket`. The first of these
    /// packets has a PTS of zero, and the user wishes playback to begin as soon
    /// as possible, but wishes to skip all of the audio content between PTS 0
    /// and PTS 'media_time'. The user would call
    /// `Play(NO_TIMESTAMP, media_time)`.
    ///
    /// 4. A user has queued some audio using `SendPacket` and want to present
    /// this media in synch with another player in a different device. The
    /// coordinator of the group of distributed players sends an explicit
    /// message to each player telling them to begin presentation of audio at
    /// PTS 'media_time', at the time (based on the group's shared reference
    /// clock) 'reference_time'. Here the user would call
    /// `Play(reference_time, media_time)`.
    pub fn r#play(
        &self,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioRendererProxyInterface::r#play(self, reference_time, media_time)
    }

    pub fn r#play_no_reply(
        &self,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#play_no_reply(self, reference_time, media_time)
    }

    /// Immediately puts the AudioRenderer into the paused state and then report
    /// the relationship between the media and reference timelines which was
    /// established (if requested).
    ///
    /// If the AudioRenderer is already in the paused state when this called,
    /// the previously-established timeline values are returned (if requested).
    pub fn r#pause(
        &self,
    ) -> fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AudioRendererProxyInterface::r#pause(self)
    }

    pub fn r#pause_no_reply(&self) -> Result<(), fidl::Error> {
        AudioRendererProxyInterface::r#pause_no_reply(self)
    }
}

impl AudioRendererProxyInterface for AudioRendererProxy {
    fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SendPacketResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        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,
                0x67cddd607442775f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<StreamSinkSendPacketRequest, ()>(
            (packet,),
            0x67cddd607442775f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_gain_control(
        &self,
        mut gain_control_request: fidl::endpoints::ServerEnd<
            fidl_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererBindGainControlRequest>(
            (gain_control_request,),
            0x293f5c7f8fba2bdc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_pts_units(
        &self,
        mut tick_per_second_numerator: u32,
        mut tick_per_second_denominator: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPtsUnitsRequest>(
            (tick_per_second_numerator, tick_per_second_denominator),
            0xf68cd108785a27c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_pts_continuity_threshold(
        &self,
        mut threshold_seconds: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPtsContinuityThresholdRequest>(
            (threshold_seconds,),
            0x2849ba571d1971ba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetReferenceClockResponseFut =
        fidl::client::QueryResponseFut<fidl::Clock, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Clock, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererGetReferenceClockResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f7a7f011a172f7e,
            >(_buf?)?;
            Ok(_response.reference_clock)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fidl::Clock>(
            (),
            0x2f7a7f011a172f7e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fidl::Clock>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetReferenceClockRequest>(
            (reference_clock,),
            0x39acd05d832b5fed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_usage(&self, mut usage: AudioRenderUsage) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetUsageRequest>(
            (usage,),
            0x3994bd23b55a733e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_usage2(&self, mut usage2: AudioRenderUsage2) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetUsage2Request>(
            (usage2,),
            0x2904035c7132b103,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#set_pcm_stream_type(&self, mut type_: &AudioStreamType) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererSetPcmStreamTypeRequest>(
            (type_,),
            0x27aa715d8901fa19,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#enable_min_lead_time_events(&self, mut enabled: bool) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererEnableMinLeadTimeEventsRequest>(
            (enabled,),
            0x62808dfad72bf890,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetMinLeadTimeResponseFut =
        fidl::client::QueryResponseFut<i64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_min_lead_time(&self) -> Self::GetMinLeadTimeResponseFut {
        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::<
                AudioRendererGetMinLeadTimeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cf3c3ecd8fec26b,
            >(_buf?)?;
            Ok(_response.min_lead_time_nsec)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i64>(
            (),
            0x1cf3c3ecd8fec26b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type PlayResponseFut =
        fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#play(&self, mut reference_time: i64, mut media_time: i64) -> Self::PlayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererPlayResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3c0162db084f74a3,
            >(_buf?)?;
            Ok((_response.reference_time, _response.media_time))
        }
        self.client.send_query_and_decode::<AudioRendererPlayRequest, (i64, i64)>(
            (reference_time, media_time),
            0x3c0162db084f74a3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#play_no_reply(
        &self,
        mut reference_time: i64,
        mut media_time: i64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioRendererPlayNoReplyRequest>(
            (reference_time, media_time),
            0x1b7fe832b68c22ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type PauseResponseFut =
        fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#pause(&self) -> Self::PauseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererPauseResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x41d557588d93d153,
            >(_buf?)?;
            Ok((_response.reference_time, _response.media_time))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i64, i64)>(
            (),
            0x41d557588d93d153,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#pause_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x24cc45d4f3855ab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl AudioRendererEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_min_lead_time_changed(self) -> Option<i64> {
        if let AudioRendererEvent::OnMinLeadTimeChanged { min_lead_time_nsec } = self {
            Some((min_lead_time_nsec))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::RequestStream for AudioRendererRequestStream {
    type Protocol = AudioRendererMarker;
    type ControlHandle = AudioRendererControlHandle;

    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 {
        AudioRendererControlHandle { 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 AudioRendererRequestStream {
    type Item = Result<AudioRendererRequest, 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 AudioRendererRequestStream 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 {
                    0x3b3a37fc34fe5b56 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetAddPayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetAddPayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::AddPayloadBuffer {
                            id: req.id,
                            payload_buffer: req.payload_buffer,

                            control_handle,
                        })
                    }
                    0x5d1e4f74c3658262 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetRemovePayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetRemovePayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::RemovePayloadBuffer { id: req.id, control_handle })
                    }
                    0x67cddd607442775f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SendPacket {
                            packet: req.packet,

                            responder: AudioRendererSendPacketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x8d9b8b413ceba9d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketNoReplyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketNoReplyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SendPacketNoReply {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x6180fd6f7e793b71 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::EndOfStream { control_handle })
                    }
                    0x6f4dad7af2917665 => {
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::DiscardAllPackets {
                            responder: AudioRendererDiscardAllPacketsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x50d36d0d23081bc4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    0x293f5c7f8fba2bdc => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererBindGainControlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererBindGainControlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::BindGainControl {
                            gain_control_request: req.gain_control_request,

                            control_handle,
                        })
                    }
                    0xf68cd108785a27c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetPtsUnitsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetPtsUnitsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetPtsUnits {
                            tick_per_second_numerator: req.tick_per_second_numerator,
                            tick_per_second_denominator: req.tick_per_second_denominator,

                            control_handle,
                        })
                    }
                    0x2849ba571d1971ba => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetPtsContinuityThresholdRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetPtsContinuityThresholdRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetPtsContinuityThreshold {
                            threshold_seconds: req.threshold_seconds,

                            control_handle,
                        })
                    }
                    0x2f7a7f011a172f7e => {
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::GetReferenceClock {
                            responder: AudioRendererGetReferenceClockResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x39acd05d832b5fed => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetReferenceClockRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetReferenceClockRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetReferenceClock {
                            reference_clock: req.reference_clock,

                            control_handle,
                        })
                    }
                    0x3994bd23b55a733e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetUsageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetUsageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetUsage { usage: req.usage, control_handle })
                    }
                    0x2904035c7132b103 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetUsage2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetUsage2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetUsage2 { usage2: req.usage2, control_handle })
                    }
                    0x27aa715d8901fa19 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererSetPcmStreamTypeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererSetPcmStreamTypeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::SetPcmStreamType {
                            type_: req.type_,

                            control_handle,
                        })
                    }
                    0x62808dfad72bf890 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererEnableMinLeadTimeEventsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererEnableMinLeadTimeEventsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::EnableMinLeadTimeEvents {
                            enabled: req.enabled,

                            control_handle,
                        })
                    }
                    0x1cf3c3ecd8fec26b => {
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::GetMinLeadTime {
                            responder: AudioRendererGetMinLeadTimeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3c0162db084f74a3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererPlayRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererPlayRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::Play {
                            reference_time: req.reference_time,
                            media_time: req.media_time,

                            responder: AudioRendererPlayResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1b7fe832b68c22ef => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AudioRendererPlayNoReplyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AudioRendererPlayNoReplyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::PlayNoReply {
                            reference_time: req.reference_time,
                            media_time: req.media_time,

                            control_handle,
                        })
                    }
                    0x41d557588d93d153 => {
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::Pause {
                            responder: AudioRendererPauseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24cc45d4f3855ab => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            AudioRendererControlHandle { inner: this.inner.clone() };
                        Ok(AudioRendererRequest::PauseNoReply { control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AudioRendererRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioRendererControlHandle {
                                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(AudioRendererRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AudioRendererControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AudioRendererMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// AudioRenderers can be in one of two states at any time: _configurable_ or _operational_. A
/// renderer is considered operational whenever it has packets queued to be rendered; otherwise it
/// is _configurable_. Once an AudioRenderer enters the operational state, calls to "configuring"
/// methods are disallowed and will cause the audio service to disconnect the client's connection.
/// The following are considered configuring methods: `AddPayloadBuffer`, `SetPcmStreamType`,
/// `SetStreamType`, `SetPtsUnits`, `SetPtsContinuityThreshold`.
///
/// If an AudioRenderer must be reconfigured, the client must ensure that no packets are still
/// enqueued when these "configuring" methods are called. Thus it is best practice to call
/// `DiscardAllPackets` on the AudioRenderer (and ideally `Stop` before `DiscardAllPackets`), prior
/// to reconfiguring the renderer.
#[derive(Debug)]
pub enum AudioRendererRequest {
    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    AddPayloadBuffer {
        id: u32,
        payload_buffer: fidl::Vmo,
        control_handle: AudioRendererControlHandle,
    },
    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    RemovePayloadBuffer {
        id: u32,
        control_handle: AudioRendererControlHandle,
    },
    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacket {
        packet: StreamPacket,
        responder: AudioRendererSendPacketResponder,
    },
    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacketNoReply {
        packet: StreamPacket,
        control_handle: AudioRendererControlHandle,
    },
    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    EndOfStream {
        control_handle: AudioRendererControlHandle,
    },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    DiscardAllPackets {
        responder: AudioRendererDiscardAllPacketsResponder,
    },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    DiscardAllPacketsNoReply {
        control_handle: AudioRendererControlHandle,
    },
    /// Binds to the gain control for this AudioRenderer.
    BindGainControl {
        gain_control_request:
            fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
        control_handle: AudioRendererControlHandle,
    },
    /// Sets the units used by the presentation (media) timeline. By default, PTS units are
    /// nanoseconds (as if this were called with numerator of 1e9 and denominator of 1).
    /// This ratio must lie between 1/60 (1 tick per minute) and 1e9/1 (1ns per tick).
    SetPtsUnits {
        tick_per_second_numerator: u32,
        tick_per_second_denominator: u32,
        control_handle: AudioRendererControlHandle,
    },
    /// Sets the maximum threshold (in seconds) between explicit user-provided PTS
    /// and expected PTS (determined using interpolation). Beyond this threshold,
    /// a stream is no longer considered 'continuous' by the renderer.
    ///
    /// Defaults to an interval of half a PTS 'tick', using the currently-defined PTS units.
    /// Most users should not need to change this value from its default.
    ///
    /// Example:
    /// A user is playing back 48KHz audio from a container, which also contains
    /// video and needs to be synchronized with the audio. The timestamps are
    /// provided explicitly per packet by the container, and expressed in mSec
    /// units. This means that a single tick of the media timeline (1 mSec)
    /// represents exactly 48 frames of audio. The application in this scenario
    /// delivers packets of audio to the AudioRenderer, each with exactly 470
    /// frames of audio, and each with an explicit timestamp set to the best
    /// possible representation of the presentation time (given this media
    /// clock's resolution). So, starting from zero, the timestamps would be..
    ///
    /// [ 0, 10, 20, 29, 39, 49, 59, 69, 78, 88, ... ]
    ///
    /// In this example, attempting to use the presentation time to compute the
    /// starting frame number of the audio in the packet would be wrong the
    /// majority of the time. The first timestamp is correct (by definition), but
    /// it will be 24 packets before the timestamps and frame numbers come back
    /// into alignment (the 24th packet would start with the 11280th audio frame
    /// and have a PTS of exactly 235).
    ///
    /// One way to fix this situation is to set the PTS continuity threshold
    /// (henceforth, CT) for the stream to be equal to 1/2 of the time taken by
    /// the number of frames contained within a single tick of the media clock,
    /// rounded up. In this scenario, that would be 24.0 frames of audio, or 500
    /// uSec. Any packets whose expected PTS was within +/-CT frames of the
    /// explicitly provided PTS would be considered to be a continuation of the
    /// previous frame of audio. For this example, calling 'SetPtsContinuityThreshold(0.0005)'
    /// would work well.
    ///
    /// Other possible uses:
    /// Users who are scheduling audio explicitly, relative to a clock which has
    /// not been configured as the reference clock, can use this value to control
    /// the maximum acceptable synchronization error before a discontinuity is
    /// introduced. E.g., if a user is scheduling audio based on a recovered
    /// common media clock, and has not published that clock as the reference
    /// clock, and they set the CT to 20mSec, then up to 20mSec of drift error
    /// can accumulate before the AudioRenderer deliberately inserts a
    /// presentation discontinuity to account for the error.
    ///
    /// Users whose need to deal with a container where their timestamps may be
    /// even less correct than +/- 1/2 of a PTS tick may set this value to
    /// something larger. This should be the maximum level of inaccuracy present
    /// in the container timestamps, if known. Failing that, it could be set to
    /// the maximum tolerable level of drift error before absolute timestamps are
    /// explicitly obeyed. Finally, a user could set this number to a very large
    /// value (86400.0 seconds, for example) to effectively cause *all*
    /// timestamps to be ignored after the first, thus treating all audio as
    /// continuous with previously delivered packets. Conversely, users who wish
    /// to *always* explicitly schedule their audio packets exactly may specify
    /// a CT of 0.
    ///
    /// Note: explicitly specifying high-frequency PTS units reduces the default
    /// continuity threshold accordingly. Internally, this threshold is stored as an
    /// integer of 1/8192 subframes. The default threshold is computed as follows:
    ///     RoundUp((AudioFPS/PTSTicksPerSec) * 4096) / (AudioFPS * 8192)
    /// For this reason, specifying PTS units with a frequency greater than 8192x
    /// the frame rate (or NOT calling SetPtsUnits, which accepts the default PTS
    /// unit of 1 nanosec) will result in a default continuity threshold of zero.
    SetPtsContinuityThreshold {
        threshold_seconds: f32,
        control_handle: AudioRendererControlHandle,
    },
    /// Retrieves the stream's reference clock. The returned handle will have READ, DUPLICATE
    /// and TRANSFER rights, and will refer to a zx::clock that is MONOTONIC and CONTINUOUS.
    GetReferenceClock {
        responder: AudioRendererGetReferenceClockResponder,
    },
    /// Sets the reference clock that controls this renderer's playback rate. If the input
    /// parameter is a valid zx::clock, it must have READ, DUPLICATE, TRANSFER rights and
    /// refer to a clock that is both MONOTONIC and CONTINUOUS. If instead an invalid clock
    /// is passed (such as the uninitialized `zx::clock()`), this indicates that the stream
    /// will use a 'flexible' clock generated by AudioCore that tracks the audio device.
    ///
    /// `SetReferenceClock` cannot be called once `SetPcmStreamType` is called. It also
    /// cannot be called a second time (even if the renderer format has not yet been set).
    /// If a client wants a reference clock that is initially `CLOCK_MONOTONIC` but may
    /// diverge at some later time, they should create a clone of the monotonic clock, set
    /// this as the stream's reference clock, then rate-adjust it subsequently as needed.
    SetReferenceClock {
        reference_clock: Option<fidl::Clock>,
        control_handle: AudioRendererControlHandle,
    },
    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    SetUsage {
        usage: AudioRenderUsage,
        control_handle: AudioRendererControlHandle,
    },
    /// Sets the usage of the render stream. This method may not be called after
    /// `SetPcmStreamType` is called. The default usage is `MEDIA`.
    SetUsage2 {
        usage2: AudioRenderUsage2,
        control_handle: AudioRendererControlHandle,
    },
    /// Sets the type of the stream to be delivered by the client. Using this method implies
    /// that the stream encoding is `AUDIO_ENCODING_LPCM`.
    ///
    /// This must be called before `Play` or `PlayNoReply`. After a call to `SetPcmStreamType`,
    /// the client must then send an `AddPayloadBuffer` request, then the various `StreamSink`
    /// methods such as `SendPacket`/`SendPacketNoReply`.
    SetPcmStreamType {
        type_: AudioStreamType,
        control_handle: AudioRendererControlHandle,
    },
    /// Enables or disables notifications about changes to the minimum clock lead
    /// time (in nanoseconds) for this AudioRenderer. Calling this method with
    /// 'enabled' set to true will trigger an immediate `OnMinLeadTimeChanged`
    /// event with the current minimum lead time for the AudioRenderer. If the
    /// value changes, an `OnMinLeadTimeChanged` event will be raised with the
    /// new value. This behavior will continue until the user calls
    /// `EnableMinLeadTimeEvents(false)`.
    ///
    /// The minimum clock lead time is the amount of time ahead of the reference
    /// clock's understanding of "now" that packets needs to arrive (relative to
    /// the playback clock transformation) in order for the mixer to be able to
    /// mix packet. For example...
    ///
    /// + Let the PTS of packet X be P(X)
    /// + Let the function which transforms PTS -> RefClock be R(p) (this
    ///   function is determined by the call to Play(...)
    /// + Let the minimum lead time be MLT
    ///
    /// If R(P(X)) < RefClock.Now() + MLT
    /// Then the packet is late, and some (or all) of the packet's payload will
    /// need to be skipped in order to present the packet at the scheduled time.
    ///
    /// The value `min_lead_time_nsec = 0` is a special value which indicates
    /// that the AudioRenderer is not yet routed to an output device. If `Play`
    /// is called before the AudioRenderer is routed, any played packets will be
    /// dropped. Clients should wait until `min_lead_time_nsec > 0` before
    /// calling `Play`.
    EnableMinLeadTimeEvents {
        enabled: bool,
        control_handle: AudioRendererControlHandle,
    },
    ///
    /// While it is possible to call `GetMinLeadTime` before `SetPcmStreamType`,
    /// there's little reason to do so. This is because lead time is a function
    /// of format/rate, so lead time will be recalculated after `SetPcmStreamType`.
    /// If min lead time events are enabled before `SetPcmStreamType` (with
    /// `EnableMinLeadTimeEvents(true)`), then an event will be generated in
    /// response to `SetPcmStreamType`.
    GetMinLeadTime {
        responder: AudioRendererGetMinLeadTimeResponder,
    },
    /// Immediately puts the AudioRenderer into a playing state. Starts the advance
    /// of the media timeline, using specific values provided by the caller (or
    /// default values if not specified). In an optional callback, returns the
    /// timestamp values ultimately used -- these set the ongoing relationship
    /// between the media and reference timelines (i.e., how to translate between
    /// the domain of presentation timestamps, and the realm of local system
    /// time).
    ///
    /// Local system time is specified in units of nanoseconds; media_time is
    /// specified in the units defined by the user in the `SetPtsUnits` function,
    /// or nanoseconds if `SetPtsUnits` is not called.
    ///
    /// The act of placing an AudioRenderer into the playback state establishes a
    /// relationship between 1) the user-defined media (or presentation) timeline
    /// for this particular AudioRenderer, and 2) the real-world system reference
    /// timeline. To communicate how to translate between timelines, the Play()
    /// callback provides an equivalent timestamp in each time domain. The first
    /// value ('reference_time') is given in terms of this renderer's reference
    /// clock; the second value ('media_time') is what media instant exactly
    /// corresponds to that local time. Restated, the frame at 'media_time' in
    /// the audio stream should be presented at 'reference_time' according to
    /// the reference clock.
    ///
    /// Note: on calling this API, media_time immediately starts advancing. It is
    /// possible (if uncommon) for a caller to specify a system time that is
    /// far in the past, or far into the future. This, along with the specified
    /// media time, is simply used to determine what media time corresponds to
    /// 'now', and THAT media time is then intersected with presentation
    /// timestamps of packets already submitted, to determine which media frames
    /// should be presented next.
    ///
    /// With the corresponding reference_time and media_time values, a user can
    /// translate arbitrary time values from one timeline into the other. After
    /// calling `SetPtsUnits(pts_per_sec_numerator, pts_per_sec_denominator)` and
    /// given the 'ref_start' and 'media_start' values from `Play`, then for
    /// any 'ref_time':
    ///
    /// media_time = ( (ref_time - ref_start) / 1e9
    ///                * (pts_per_sec_numerator / pts_per_sec_denominator) )
    ///              + media_start
    ///
    /// Conversely, for any presentation timestamp 'media_time':
    ///
    /// ref_time = ( (media_time - media_start)
    ///              * (pts_per_sec_denominator / pts_per_sec_numerator)
    ///              * 1e9 )
    ///            + ref_start
    ///
    /// Users, depending on their use case, may optionally choose not to specify
    /// one or both of these timestamps. A timestamp may be omitted by supplying
    /// the special value '`NO_TIMESTAMP`'. The AudioRenderer automatically deduces
    /// any omitted timestamp value using the following rules:
    ///
    /// Reference Time
    /// If 'reference_time' is omitted, the AudioRenderer will select a "safe"
    /// reference time to begin presentation, based on the minimum lead times for
    /// the output devices that are currently bound to this AudioRenderer. For
    /// example, if an AudioRenderer is bound to an internal audio output
    /// requiring at least 3 mSec of lead time, and an HDMI output requiring at
    /// least 75 mSec of lead time, the AudioRenderer might (if 'reference_time'
    /// is omitted) select a reference time 80 mSec from now.
    ///
    /// Media Time
    /// If media_time is omitted, the AudioRenderer will select one of two
    /// values.
    /// - If the AudioRenderer is resuming from the paused state, and packets
    /// have not been discarded since being paused, then the AudioRenderer will
    /// use a media_time corresponding to the instant at which the presentation
    /// became paused.
    /// - If the AudioRenderer is being placed into a playing state for the first
    /// time following startup or a 'discard packets' operation, the initial
    /// media_time will be set to the PTS of the first payload in the pending
    /// packet queue. If the pending queue is empty, initial media_time will be
    /// set to zero.
    ///
    /// Return Value
    /// When requested, the AudioRenderer will return the 'reference_time' and
    /// 'media_time' which were selected and used (whether they were explicitly
    /// specified or not) in the return value of the play call.
    ///
    /// Examples
    /// 1. A user has queued some audio using `SendPacket` and simply wishes them
    /// to start playing as soon as possible. The user may call Play without
    /// providing explicit timestamps -- `Play(NO_TIMESTAMP, NO_TIMESTAMP)`.
    ///
    /// 2. A user has queued some audio using `SendPacket`, and wishes to start
    /// playback at a specified 'reference_time', in sync with some other media
    /// stream, either initially or after discarding packets. The user would call
    /// `Play(reference_time, NO_TIMESTAMP)`.
    ///
    /// 3. A user has queued some audio using `SendPacket`. The first of these
    /// packets has a PTS of zero, and the user wishes playback to begin as soon
    /// as possible, but wishes to skip all of the audio content between PTS 0
    /// and PTS 'media_time'. The user would call
    /// `Play(NO_TIMESTAMP, media_time)`.
    ///
    /// 4. A user has queued some audio using `SendPacket` and want to present
    /// this media in synch with another player in a different device. The
    /// coordinator of the group of distributed players sends an explicit
    /// message to each player telling them to begin presentation of audio at
    /// PTS 'media_time', at the time (based on the group's shared reference
    /// clock) 'reference_time'. Here the user would call
    /// `Play(reference_time, media_time)`.
    Play {
        reference_time: i64,
        media_time: i64,
        responder: AudioRendererPlayResponder,
    },
    PlayNoReply {
        reference_time: i64,
        media_time: i64,
        control_handle: AudioRendererControlHandle,
    },
    /// Immediately puts the AudioRenderer into the paused state and then report
    /// the relationship between the media and reference timelines which was
    /// established (if requested).
    ///
    /// If the AudioRenderer is already in the paused state when this called,
    /// the previously-established timeline values are returned (if requested).
    Pause {
        responder: AudioRendererPauseResponder,
    },
    PauseNoReply {
        control_handle: AudioRendererControlHandle,
    },
    /// 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: AudioRendererControlHandle,
        method_type: fidl::MethodType,
    },
}

impl AudioRendererRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_payload_buffer(self) -> Option<(u32, fidl::Vmo, AudioRendererControlHandle)> {
        if let AudioRendererRequest::AddPayloadBuffer { id, payload_buffer, control_handle } = self
        {
            Some((id, payload_buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_payload_buffer(self) -> Option<(u32, AudioRendererControlHandle)> {
        if let AudioRendererRequest::RemovePayloadBuffer { id, control_handle } = self {
            Some((id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet(self) -> Option<(StreamPacket, AudioRendererSendPacketResponder)> {
        if let AudioRendererRequest::SendPacket { packet, responder } = self {
            Some((packet, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet_no_reply(self) -> Option<(StreamPacket, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SendPacketNoReply { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_end_of_stream(self) -> Option<(AudioRendererControlHandle)> {
        if let AudioRendererRequest::EndOfStream { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets(self) -> Option<(AudioRendererDiscardAllPacketsResponder)> {
        if let AudioRendererRequest::DiscardAllPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets_no_reply(self) -> Option<(AudioRendererControlHandle)> {
        if let AudioRendererRequest::DiscardAllPacketsNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_gain_control(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::GainControlMarker>,
        AudioRendererControlHandle,
    )> {
        if let AudioRendererRequest::BindGainControl { gain_control_request, control_handle } = self
        {
            Some((gain_control_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pts_units(self) -> Option<(u32, u32, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetPtsUnits {
            tick_per_second_numerator,
            tick_per_second_denominator,
            control_handle,
        } = self
        {
            Some((tick_per_second_numerator, tick_per_second_denominator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pts_continuity_threshold(self) -> Option<(f32, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetPtsContinuityThreshold {
            threshold_seconds,
            control_handle,
        } = self
        {
            Some((threshold_seconds, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reference_clock(self) -> Option<(AudioRendererGetReferenceClockResponder)> {
        if let AudioRendererRequest::GetReferenceClock { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reference_clock(
        self,
    ) -> Option<(Option<fidl::Clock>, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetReferenceClock { reference_clock, control_handle } = self {
            Some((reference_clock, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_usage(self) -> Option<(AudioRenderUsage, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetUsage { usage, control_handle } = self {
            Some((usage, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_usage2(self) -> Option<(AudioRenderUsage2, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetUsage2 { usage2, control_handle } = self {
            Some((usage2, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pcm_stream_type(self) -> Option<(AudioStreamType, AudioRendererControlHandle)> {
        if let AudioRendererRequest::SetPcmStreamType { type_, control_handle } = self {
            Some((type_, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_min_lead_time_events(self) -> Option<(bool, AudioRendererControlHandle)> {
        if let AudioRendererRequest::EnableMinLeadTimeEvents { enabled, control_handle } = self {
            Some((enabled, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_min_lead_time(self) -> Option<(AudioRendererGetMinLeadTimeResponder)> {
        if let AudioRendererRequest::GetMinLeadTime { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_play(self) -> Option<(i64, i64, AudioRendererPlayResponder)> {
        if let AudioRendererRequest::Play { reference_time, media_time, responder } = self {
            Some((reference_time, media_time, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_play_no_reply(self) -> Option<(i64, i64, AudioRendererControlHandle)> {
        if let AudioRendererRequest::PlayNoReply { reference_time, media_time, control_handle } =
            self
        {
            Some((reference_time, media_time, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pause(self) -> Option<(AudioRendererPauseResponder)> {
        if let AudioRendererRequest::Pause { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pause_no_reply(self) -> Option<(AudioRendererControlHandle)> {
        if let AudioRendererRequest::PauseNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AudioRendererRequest::AddPayloadBuffer { .. } => "add_payload_buffer",
            AudioRendererRequest::RemovePayloadBuffer { .. } => "remove_payload_buffer",
            AudioRendererRequest::SendPacket { .. } => "send_packet",
            AudioRendererRequest::SendPacketNoReply { .. } => "send_packet_no_reply",
            AudioRendererRequest::EndOfStream { .. } => "end_of_stream",
            AudioRendererRequest::DiscardAllPackets { .. } => "discard_all_packets",
            AudioRendererRequest::DiscardAllPacketsNoReply { .. } => "discard_all_packets_no_reply",
            AudioRendererRequest::BindGainControl { .. } => "bind_gain_control",
            AudioRendererRequest::SetPtsUnits { .. } => "set_pts_units",
            AudioRendererRequest::SetPtsContinuityThreshold { .. } => {
                "set_pts_continuity_threshold"
            }
            AudioRendererRequest::GetReferenceClock { .. } => "get_reference_clock",
            AudioRendererRequest::SetReferenceClock { .. } => "set_reference_clock",
            AudioRendererRequest::SetUsage { .. } => "set_usage",
            AudioRendererRequest::SetUsage2 { .. } => "set_usage2",
            AudioRendererRequest::SetPcmStreamType { .. } => "set_pcm_stream_type",
            AudioRendererRequest::EnableMinLeadTimeEvents { .. } => "enable_min_lead_time_events",
            AudioRendererRequest::GetMinLeadTime { .. } => "get_min_lead_time",
            AudioRendererRequest::Play { .. } => "play",
            AudioRendererRequest::PlayNoReply { .. } => "play_no_reply",
            AudioRendererRequest::Pause { .. } => "pause",
            AudioRendererRequest::PauseNoReply { .. } => "pause_no_reply",
            AudioRendererRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            AudioRendererRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AudioRendererControlHandle {
    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 AudioRendererControlHandle {
    pub fn send_on_min_lead_time_changed(
        &self,
        mut min_lead_time_nsec: i64,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<AudioRendererOnMinLeadTimeChangedRequest>(
            (min_lead_time_nsec,),
            0,
            0x4feff7d278978c4e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut reference_clock: fidl::Clock) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioRendererGetReferenceClockResponse>(
            (reference_clock,),
            self.tx_id,
            0x2f7a7f011a172f7e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut reference_time: i64, mut media_time: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioRendererPlayResponse>(
            (reference_time, media_time),
            self.tx_id,
            0x3c0162db084f74a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut reference_time: i64, mut media_time: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AudioRendererPauseResponse>(
            (reference_time, media_time),
            self.tx_id,
            0x41d557588d93d153,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ProfileProviderMarker {
    type Proxy = ProfileProviderProxy;
    type RequestStream = ProfileProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProfileProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.ProfileProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ProfileProviderMarker {}

pub trait ProfileProviderProxyInterface: Send + Sync {
    type RegisterHandlerWithCapacityResponseFut: std::future::Future<Output = Result<(i64, i64), fidl::Error>>
        + Send;
    fn r#register_handler_with_capacity(
        &self,
        thread_handle: fidl::Thread,
        name: &str,
        period: i64,
        capacity: f32,
    ) -> Self::RegisterHandlerWithCapacityResponseFut;
    type UnregisterHandlerResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#unregister_handler(
        &self,
        thread_handle: fidl::Thread,
        name: &str,
    ) -> Self::UnregisterHandlerResponseFut;
    type RegisterMemoryRangeResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#register_memory_range(
        &self,
        vmar_handle: fidl::Vmar,
        name: &str,
    ) -> Self::RegisterMemoryRangeResponseFut;
    type UnregisterMemoryRangeResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#unregister_memory_range(
        &self,
        vmar_handle: fidl::Vmar,
    ) -> Self::UnregisterMemoryRangeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProfileProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProfileProviderSynchronousProxy {
    type Proxy = ProfileProviderProxy;
    type Protocol = ProfileProviderMarker;

    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 ProfileProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ProfileProviderMarker 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<ProfileProviderEvent, fidl::Error> {
        ProfileProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Register a thread as a media thread. This notifies the media subsystem that this thread
    /// should have an elevated scheduling profile applied to it in order to meet audio or video
    /// deadlines.
    ///
    /// `name` is the name of a system scheduling role to apply to the thread given by
    /// `thread_handle` -- different products may customize the underlying scheduling strategy based
    /// on the requested role. `period` is the suggested interval to be scheduled at. `period` may
    /// be zero if the thread has no preferred scheduling interval. `capacity` is the proportion of
    /// the scheduling interval the thread needs to be running to achieve good performance or to
    /// meet the scheduling deadline defined by `period`. `capacity` may be zero if the workload has
    /// no firm runtime requirements. Note that `capacity` should be a good faith estimate based on
    /// the worst case runtime the thread requires each period.  Excessive capacity requests may
    /// be rejected or result in scaling back the performance of other threads to fit resource
    /// limits.
    ///
    /// Capacity, max runtime, and period have the following relationship:
    ///
    ///   capacity = max runtime / period
    ///
    /// Where:
    ///
    ///   0 <= max runtime <= period    and    0 <= capacity <= 1
    ///
    /// For heterogeneous systems, the capacity should be planned / measured against the highest
    /// performance processor(s) in the system. The system will automatically adjust the effective
    /// capacity to account for slower processors and operating points and will avoid processors and
    /// operating points that are too slow to meet the requested scheduling parameters (provided
    /// they are reasonable).
    ///
    /// Returns the period and capacity (actually maximum runtime) that was applied, either of which
    /// may be zero to indicate not applicable.
    pub fn r#register_handler_with_capacity(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
        mut period: i64,
        mut capacity: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i64, i64), fidl::Error> {
        let _response = self.client.send_query::<
            ProfileProviderRegisterHandlerWithCapacityRequest,
            ProfileProviderRegisterHandlerWithCapacityResponse,
        >(
            (thread_handle, name, period, capacity,),
            0x60459ecef7458176,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.period, _response.capacity))
    }

    /// Reset a thread's scheduling profile to the default.
    pub fn r#unregister_handler(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<ProfileProviderUnregisterHandlerRequest, fidl::encoding::EmptyPayload>(
                (thread_handle, name),
                0x724d9d5fd8ef544c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Register a memory range as being used for media processing. This notifies the media
    /// subsystem that this memory should have an elevated memory profile applied to it in order to
    /// meet audio or video deadlines.
    ///
    /// `name` is the name of a system memory role to apply to the memory given by
    /// `vmar_handle` -- different products may customize the underlying memory strategy based
    /// on the requested role.
    pub fn r#register_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<ProfileProviderRegisterMemoryRangeRequest, fidl::encoding::EmptyPayload>(
                (vmar_handle, name),
                0x2f509d3523e9562d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Reset a memory range's memory profile.
    pub fn r#unregister_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            ProfileProviderUnregisterMemoryRangeRequest,
            fidl::encoding::EmptyPayload,
        >(
            (vmar_handle,),
            0x2dc313d6aa81ad27,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ProfileProviderProxy {
    type Protocol = ProfileProviderMarker;

    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 ProfileProviderProxy {
    /// Create a new Proxy for fuchsia.media/ProfileProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ProfileProviderMarker 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) -> ProfileProviderEventStream {
        ProfileProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register a thread as a media thread. This notifies the media subsystem that this thread
    /// should have an elevated scheduling profile applied to it in order to meet audio or video
    /// deadlines.
    ///
    /// `name` is the name of a system scheduling role to apply to the thread given by
    /// `thread_handle` -- different products may customize the underlying scheduling strategy based
    /// on the requested role. `period` is the suggested interval to be scheduled at. `period` may
    /// be zero if the thread has no preferred scheduling interval. `capacity` is the proportion of
    /// the scheduling interval the thread needs to be running to achieve good performance or to
    /// meet the scheduling deadline defined by `period`. `capacity` may be zero if the workload has
    /// no firm runtime requirements. Note that `capacity` should be a good faith estimate based on
    /// the worst case runtime the thread requires each period.  Excessive capacity requests may
    /// be rejected or result in scaling back the performance of other threads to fit resource
    /// limits.
    ///
    /// Capacity, max runtime, and period have the following relationship:
    ///
    ///   capacity = max runtime / period
    ///
    /// Where:
    ///
    ///   0 <= max runtime <= period    and    0 <= capacity <= 1
    ///
    /// For heterogeneous systems, the capacity should be planned / measured against the highest
    /// performance processor(s) in the system. The system will automatically adjust the effective
    /// capacity to account for slower processors and operating points and will avoid processors and
    /// operating points that are too slow to meet the requested scheduling parameters (provided
    /// they are reasonable).
    ///
    /// Returns the period and capacity (actually maximum runtime) that was applied, either of which
    /// may be zero to indicate not applicable.
    pub fn r#register_handler_with_capacity(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
        mut period: i64,
        mut capacity: f32,
    ) -> fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ProfileProviderProxyInterface::r#register_handler_with_capacity(
            self,
            thread_handle,
            name,
            period,
            capacity,
        )
    }

    /// Reset a thread's scheduling profile to the default.
    pub fn r#unregister_handler(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ProfileProviderProxyInterface::r#unregister_handler(self, thread_handle, name)
    }

    /// Register a memory range as being used for media processing. This notifies the media
    /// subsystem that this memory should have an elevated memory profile applied to it in order to
    /// meet audio or video deadlines.
    ///
    /// `name` is the name of a system memory role to apply to the memory given by
    /// `vmar_handle` -- different products may customize the underlying memory strategy based
    /// on the requested role.
    pub fn r#register_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ProfileProviderProxyInterface::r#register_memory_range(self, vmar_handle, name)
    }

    /// Reset a memory range's memory profile.
    pub fn r#unregister_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ProfileProviderProxyInterface::r#unregister_memory_range(self, vmar_handle)
    }
}

impl ProfileProviderProxyInterface for ProfileProviderProxy {
    type RegisterHandlerWithCapacityResponseFut =
        fidl::client::QueryResponseFut<(i64, i64), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register_handler_with_capacity(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
        mut period: i64,
        mut capacity: f32,
    ) -> Self::RegisterHandlerWithCapacityResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ProfileProviderRegisterHandlerWithCapacityResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60459ecef7458176,
            >(_buf?)?;
            Ok((_response.period, _response.capacity))
        }
        self.client
            .send_query_and_decode::<ProfileProviderRegisterHandlerWithCapacityRequest, (i64, i64)>(
                (thread_handle, name, period, capacity),
                0x60459ecef7458176,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type UnregisterHandlerResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#unregister_handler(
        &self,
        mut thread_handle: fidl::Thread,
        mut name: &str,
    ) -> Self::UnregisterHandlerResponseFut {
        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,
                0x724d9d5fd8ef544c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ProfileProviderUnregisterHandlerRequest, ()>(
            (thread_handle, name),
            0x724d9d5fd8ef544c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterMemoryRangeResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
        mut name: &str,
    ) -> Self::RegisterMemoryRangeResponseFut {
        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,
                0x2f509d3523e9562d,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ProfileProviderRegisterMemoryRangeRequest, ()>(
            (vmar_handle, name),
            0x2f509d3523e9562d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnregisterMemoryRangeResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#unregister_memory_range(
        &self,
        mut vmar_handle: fidl::Vmar,
    ) -> Self::UnregisterMemoryRangeResponseFut {
        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,
                0x2dc313d6aa81ad27,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ProfileProviderUnregisterMemoryRangeRequest, ()>(
            (vmar_handle,),
            0x2dc313d6aa81ad27,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ProfileProviderRequestStream {
    type Protocol = ProfileProviderMarker;
    type ControlHandle = ProfileProviderControlHandle;

    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 {
        ProfileProviderControlHandle { 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 ProfileProviderRequestStream {
    type Item = Result<ProfileProviderRequest, 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 ProfileProviderRequestStream 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 {
                    0x60459ecef7458176 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProfileProviderRegisterHandlerWithCapacityRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProfileProviderRegisterHandlerWithCapacityRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ProfileProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProfileProviderRequest::RegisterHandlerWithCapacity {
                            thread_handle: req.thread_handle,
                            name: req.name,
                            period: req.period,
                            capacity: req.capacity,

                            responder: ProfileProviderRegisterHandlerWithCapacityResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x724d9d5fd8ef544c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProfileProviderUnregisterHandlerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProfileProviderUnregisterHandlerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ProfileProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProfileProviderRequest::UnregisterHandler {
                            thread_handle: req.thread_handle,
                            name: req.name,

                            responder: ProfileProviderUnregisterHandlerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f509d3523e9562d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProfileProviderRegisterMemoryRangeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProfileProviderRegisterMemoryRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ProfileProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProfileProviderRequest::RegisterMemoryRange {
                            vmar_handle: req.vmar_handle,
                            name: req.name,

                            responder: ProfileProviderRegisterMemoryRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2dc313d6aa81ad27 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProfileProviderUnregisterMemoryRangeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProfileProviderUnregisterMemoryRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ProfileProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProfileProviderRequest::UnregisterMemoryRange {
                            vmar_handle: req.vmar_handle,

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

#[derive(Debug)]
pub enum ProfileProviderRequest {
    /// Register a thread as a media thread. This notifies the media subsystem that this thread
    /// should have an elevated scheduling profile applied to it in order to meet audio or video
    /// deadlines.
    ///
    /// `name` is the name of a system scheduling role to apply to the thread given by
    /// `thread_handle` -- different products may customize the underlying scheduling strategy based
    /// on the requested role. `period` is the suggested interval to be scheduled at. `period` may
    /// be zero if the thread has no preferred scheduling interval. `capacity` is the proportion of
    /// the scheduling interval the thread needs to be running to achieve good performance or to
    /// meet the scheduling deadline defined by `period`. `capacity` may be zero if the workload has
    /// no firm runtime requirements. Note that `capacity` should be a good faith estimate based on
    /// the worst case runtime the thread requires each period.  Excessive capacity requests may
    /// be rejected or result in scaling back the performance of other threads to fit resource
    /// limits.
    ///
    /// Capacity, max runtime, and period have the following relationship:
    ///
    ///   capacity = max runtime / period
    ///
    /// Where:
    ///
    ///   0 <= max runtime <= period    and    0 <= capacity <= 1
    ///
    /// For heterogeneous systems, the capacity should be planned / measured against the highest
    /// performance processor(s) in the system. The system will automatically adjust the effective
    /// capacity to account for slower processors and operating points and will avoid processors and
    /// operating points that are too slow to meet the requested scheduling parameters (provided
    /// they are reasonable).
    ///
    /// Returns the period and capacity (actually maximum runtime) that was applied, either of which
    /// may be zero to indicate not applicable.
    RegisterHandlerWithCapacity {
        thread_handle: fidl::Thread,
        name: String,
        period: i64,
        capacity: f32,
        responder: ProfileProviderRegisterHandlerWithCapacityResponder,
    },
    /// Reset a thread's scheduling profile to the default.
    UnregisterHandler {
        thread_handle: fidl::Thread,
        name: String,
        responder: ProfileProviderUnregisterHandlerResponder,
    },
    /// Register a memory range as being used for media processing. This notifies the media
    /// subsystem that this memory should have an elevated memory profile applied to it in order to
    /// meet audio or video deadlines.
    ///
    /// `name` is the name of a system memory role to apply to the memory given by
    /// `vmar_handle` -- different products may customize the underlying memory strategy based
    /// on the requested role.
    RegisterMemoryRange {
        vmar_handle: fidl::Vmar,
        name: String,
        responder: ProfileProviderRegisterMemoryRangeResponder,
    },
    /// Reset a memory range's memory profile.
    UnregisterMemoryRange {
        vmar_handle: fidl::Vmar,
        responder: ProfileProviderUnregisterMemoryRangeResponder,
    },
}

impl ProfileProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_handler_with_capacity(
        self,
    ) -> Option<(fidl::Thread, String, i64, f32, ProfileProviderRegisterHandlerWithCapacityResponder)>
    {
        if let ProfileProviderRequest::RegisterHandlerWithCapacity {
            thread_handle,
            name,
            period,
            capacity,
            responder,
        } = self
        {
            Some((thread_handle, name, period, capacity, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_handler(
        self,
    ) -> Option<(fidl::Thread, String, ProfileProviderUnregisterHandlerResponder)> {
        if let ProfileProviderRequest::UnregisterHandler { thread_handle, name, responder } = self {
            Some((thread_handle, name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_memory_range(
        self,
    ) -> Option<(fidl::Vmar, String, ProfileProviderRegisterMemoryRangeResponder)> {
        if let ProfileProviderRequest::RegisterMemoryRange { vmar_handle, name, responder } = self {
            Some((vmar_handle, name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_memory_range(
        self,
    ) -> Option<(fidl::Vmar, ProfileProviderUnregisterMemoryRangeResponder)> {
        if let ProfileProviderRequest::UnregisterMemoryRange { vmar_handle, responder } = self {
            Some((vmar_handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ProfileProviderRequest::RegisterHandlerWithCapacity { .. } => {
                "register_handler_with_capacity"
            }
            ProfileProviderRequest::UnregisterHandler { .. } => "unregister_handler",
            ProfileProviderRequest::RegisterMemoryRange { .. } => "register_memory_range",
            ProfileProviderRequest::UnregisterMemoryRange { .. } => "unregister_memory_range",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ProfileProviderControlHandle {
    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 ProfileProviderControlHandle {}

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

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

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

    fn send_raw(&self, mut period: i64, mut capacity: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ProfileProviderRegisterHandlerWithCapacityResponse>(
            (period, capacity),
            self.tx_id,
            0x60459ecef7458176,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for SessionAudioConsumerFactoryMarker {
    type Proxy = SessionAudioConsumerFactoryProxy;
    type RequestStream = SessionAudioConsumerFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionAudioConsumerFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.SessionAudioConsumerFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for SessionAudioConsumerFactoryMarker {}

pub trait SessionAudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        session_id: u64,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SessionAudioConsumerFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionAudioConsumerFactorySynchronousProxy {
    type Proxy = SessionAudioConsumerFactoryProxy;
    type Protocol = SessionAudioConsumerFactoryMarker;

    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 SessionAudioConsumerFactorySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <SessionAudioConsumerFactoryMarker 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<SessionAudioConsumerFactoryEvent, fidl::Error> {
        SessionAudioConsumerFactoryEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates an `AudioConsumer`, which is an interface for playing audio, bound
    /// to a particular session. `session_id` is the identifier of the media session
    /// for which audio is to be rendered.
    pub fn r#create_audio_consumer(
        &self,
        mut session_id: u64,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<SessionAudioConsumerFactoryCreateAudioConsumerRequest>(
            (session_id, audio_consumer_request),
            0x6fab96f988e7d7fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SessionAudioConsumerFactoryProxy {
    type Protocol = SessionAudioConsumerFactoryMarker;

    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 SessionAudioConsumerFactoryProxy {
    /// Create a new Proxy for fuchsia.media/SessionAudioConsumerFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <SessionAudioConsumerFactoryMarker 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) -> SessionAudioConsumerFactoryEventStream {
        SessionAudioConsumerFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates an `AudioConsumer`, which is an interface for playing audio, bound
    /// to a particular session. `session_id` is the identifier of the media session
    /// for which audio is to be rendered.
    pub fn r#create_audio_consumer(
        &self,
        mut session_id: u64,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        SessionAudioConsumerFactoryProxyInterface::r#create_audio_consumer(
            self,
            session_id,
            audio_consumer_request,
        )
    }
}

impl SessionAudioConsumerFactoryProxyInterface for SessionAudioConsumerFactoryProxy {
    fn r#create_audio_consumer(
        &self,
        mut session_id: u64,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<SessionAudioConsumerFactoryCreateAudioConsumerRequest>(
            (session_id, audio_consumer_request),
            0x6fab96f988e7d7fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for SessionAudioConsumerFactoryRequestStream {
    type Protocol = SessionAudioConsumerFactoryMarker;
    type ControlHandle = SessionAudioConsumerFactoryControlHandle;

    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 {
        SessionAudioConsumerFactoryControlHandle { 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 SessionAudioConsumerFactoryRequestStream {
    type Item = Result<SessionAudioConsumerFactoryRequest, 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 SessionAudioConsumerFactoryRequestStream 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 {
                0x6fab96f988e7d7fb => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(SessionAudioConsumerFactoryCreateAudioConsumerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionAudioConsumerFactoryCreateAudioConsumerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SessionAudioConsumerFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SessionAudioConsumerFactoryRequest::CreateAudioConsumer {session_id: req.session_id,
audio_consumer_request: req.audio_consumer_request,

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

/// Interface for creating audio consumers bound to a session.
#[derive(Debug)]
pub enum SessionAudioConsumerFactoryRequest {
    /// Creates an `AudioConsumer`, which is an interface for playing audio, bound
    /// to a particular session. `session_id` is the identifier of the media session
    /// for which audio is to be rendered.
    CreateAudioConsumer {
        session_id: u64,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        control_handle: SessionAudioConsumerFactoryControlHandle,
    },
}

impl SessionAudioConsumerFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_consumer(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        SessionAudioConsumerFactoryControlHandle,
    )> {
        if let SessionAudioConsumerFactoryRequest::CreateAudioConsumer {
            session_id,
            audio_consumer_request,
            control_handle,
        } = self
        {
            Some((session_id, audio_consumer_request, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for SessionAudioConsumerFactoryControlHandle {
    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 SessionAudioConsumerFactoryControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for SimpleStreamSinkMarker {
    type Proxy = SimpleStreamSinkProxy;
    type RequestStream = SimpleStreamSinkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SimpleStreamSinkSynchronousProxy;

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

pub trait SimpleStreamSinkProxyInterface: Send + Sync {
    fn r#add_payload_buffer(&self, id: u32, payload_buffer: fidl::Vmo) -> Result<(), fidl::Error>;
    fn r#remove_payload_buffer(&self, id: u32) -> Result<(), fidl::Error>;
    type SendPacketResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#send_packet(&self, packet: &StreamPacket) -> Self::SendPacketResponseFut;
    fn r#send_packet_no_reply(&self, packet: &StreamPacket) -> Result<(), fidl::Error>;
    fn r#end_of_stream(&self) -> Result<(), fidl::Error>;
    type DiscardAllPacketsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut;
    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SimpleStreamSinkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SimpleStreamSinkSynchronousProxy {
    type Proxy = SimpleStreamSinkProxy;
    type Protocol = SimpleStreamSinkMarker;

    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 SimpleStreamSinkSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SimpleStreamSinkMarker 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<SimpleStreamSinkEvent, fidl::Error> {
        SimpleStreamSinkEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<StreamSinkSendPacketRequest, fidl::encoding::EmptyPayload>(
                (packet,),
                0x67cddd607442775f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x6f4dad7af2917665,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SimpleStreamSinkProxy {
    type Protocol = SimpleStreamSinkMarker;

    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 SimpleStreamSinkProxy {
    /// Create a new Proxy for fuchsia.media/SimpleStreamSink.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SimpleStreamSinkMarker 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) -> SimpleStreamSinkEventStream {
        SimpleStreamSinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        SimpleStreamSinkProxyInterface::r#add_payload_buffer(self, id, payload_buffer)
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        SimpleStreamSinkProxyInterface::r#remove_payload_buffer(self, id)
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        SimpleStreamSinkProxyInterface::r#send_packet(self, packet)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        SimpleStreamSinkProxyInterface::r#send_packet_no_reply(self, packet)
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        SimpleStreamSinkProxyInterface::r#end_of_stream(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        SimpleStreamSinkProxyInterface::r#discard_all_packets(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        SimpleStreamSinkProxyInterface::r#discard_all_packets_no_reply(self)
    }
}

impl SimpleStreamSinkProxyInterface for SimpleStreamSinkProxy {
    fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SendPacketResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        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,
                0x67cddd607442775f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<StreamSinkSendPacketRequest, ()>(
            (packet,),
            0x67cddd607442775f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for SimpleStreamSinkRequestStream {
    type Protocol = SimpleStreamSinkMarker;
    type ControlHandle = SimpleStreamSinkControlHandle;

    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 {
        SimpleStreamSinkControlHandle { 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 SimpleStreamSinkRequestStream {
    type Item = Result<SimpleStreamSinkRequest, 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 SimpleStreamSinkRequestStream 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 {
                    0x3b3a37fc34fe5b56 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetAddPayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetAddPayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::AddPayloadBuffer {
                            id: req.id,
                            payload_buffer: req.payload_buffer,

                            control_handle,
                        })
                    }
                    0x5d1e4f74c3658262 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetRemovePayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetRemovePayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::RemovePayloadBuffer {
                            id: req.id,

                            control_handle,
                        })
                    }
                    0x67cddd607442775f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::SendPacket {
                            packet: req.packet,

                            responder: SimpleStreamSinkSendPacketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x8d9b8b413ceba9d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketNoReplyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketNoReplyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::SendPacketNoReply {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x6180fd6f7e793b71 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::EndOfStream { control_handle })
                    }
                    0x6f4dad7af2917665 => {
                        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 =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::DiscardAllPackets {
                            responder: SimpleStreamSinkDiscardAllPacketsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x50d36d0d23081bc4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            SimpleStreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(SimpleStreamSinkRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SimpleStreamSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A StreamSink that uses StreamBufferSet for buffer management.
#[derive(Debug)]
pub enum SimpleStreamSinkRequest {
    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    AddPayloadBuffer {
        id: u32,
        payload_buffer: fidl::Vmo,
        control_handle: SimpleStreamSinkControlHandle,
    },
    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    RemovePayloadBuffer { id: u32, control_handle: SimpleStreamSinkControlHandle },
    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacket { packet: StreamPacket, responder: SimpleStreamSinkSendPacketResponder },
    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacketNoReply { packet: StreamPacket, control_handle: SimpleStreamSinkControlHandle },
    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    EndOfStream { control_handle: SimpleStreamSinkControlHandle },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    DiscardAllPackets { responder: SimpleStreamSinkDiscardAllPacketsResponder },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    DiscardAllPacketsNoReply { control_handle: SimpleStreamSinkControlHandle },
}

impl SimpleStreamSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_payload_buffer(
        self,
    ) -> Option<(u32, fidl::Vmo, SimpleStreamSinkControlHandle)> {
        if let SimpleStreamSinkRequest::AddPayloadBuffer { id, payload_buffer, control_handle } =
            self
        {
            Some((id, payload_buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_payload_buffer(self) -> Option<(u32, SimpleStreamSinkControlHandle)> {
        if let SimpleStreamSinkRequest::RemovePayloadBuffer { id, control_handle } = self {
            Some((id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet(self) -> Option<(StreamPacket, SimpleStreamSinkSendPacketResponder)> {
        if let SimpleStreamSinkRequest::SendPacket { packet, responder } = self {
            Some((packet, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet_no_reply(
        self,
    ) -> Option<(StreamPacket, SimpleStreamSinkControlHandle)> {
        if let SimpleStreamSinkRequest::SendPacketNoReply { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_end_of_stream(self) -> Option<(SimpleStreamSinkControlHandle)> {
        if let SimpleStreamSinkRequest::EndOfStream { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets(self) -> Option<(SimpleStreamSinkDiscardAllPacketsResponder)> {
        if let SimpleStreamSinkRequest::DiscardAllPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets_no_reply(self) -> Option<(SimpleStreamSinkControlHandle)> {
        if let SimpleStreamSinkRequest::DiscardAllPacketsNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SimpleStreamSinkRequest::AddPayloadBuffer { .. } => "add_payload_buffer",
            SimpleStreamSinkRequest::RemovePayloadBuffer { .. } => "remove_payload_buffer",
            SimpleStreamSinkRequest::SendPacket { .. } => "send_packet",
            SimpleStreamSinkRequest::SendPacketNoReply { .. } => "send_packet_no_reply",
            SimpleStreamSinkRequest::EndOfStream { .. } => "end_of_stream",
            SimpleStreamSinkRequest::DiscardAllPackets { .. } => "discard_all_packets",
            SimpleStreamSinkRequest::DiscardAllPacketsNoReply { .. } => {
                "discard_all_packets_no_reply"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for SimpleStreamSinkControlHandle {
    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 SimpleStreamSinkControlHandle {}

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for StreamBufferSetMarker {
    type Proxy = StreamBufferSetProxy;
    type RequestStream = StreamBufferSetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamBufferSetSynchronousProxy;

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

pub trait StreamBufferSetProxyInterface: Send + Sync {
    fn r#add_payload_buffer(&self, id: u32, payload_buffer: fidl::Vmo) -> Result<(), fidl::Error>;
    fn r#remove_payload_buffer(&self, id: u32) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamBufferSetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamBufferSetSynchronousProxy {
    type Proxy = StreamBufferSetProxy;
    type Protocol = StreamBufferSetMarker;

    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 StreamBufferSetSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamBufferSetMarker 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<StreamBufferSetEvent, fidl::Error> {
        StreamBufferSetEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StreamBufferSetProxy {
    type Protocol = StreamBufferSetMarker;

    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 StreamBufferSetProxy {
    /// Create a new Proxy for fuchsia.media/StreamBufferSet.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamBufferSetMarker 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) -> StreamBufferSetEventStream {
        StreamBufferSetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    pub fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        StreamBufferSetProxyInterface::r#add_payload_buffer(self, id, payload_buffer)
    }

    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    pub fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        StreamBufferSetProxyInterface::r#remove_payload_buffer(self, id)
    }
}

impl StreamBufferSetProxyInterface for StreamBufferSetProxy {
    fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fidl::Vmo,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetAddPayloadBufferRequest>(
            (id, payload_buffer),
            0x3b3a37fc34fe5b56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#remove_payload_buffer(&self, mut id: u32) -> Result<(), fidl::Error> {
        self.client.send::<StreamBufferSetRemovePayloadBufferRequest>(
            (id,),
            0x5d1e4f74c3658262,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for StreamBufferSetRequestStream {
    type Protocol = StreamBufferSetMarker;
    type ControlHandle = StreamBufferSetControlHandle;

    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 {
        StreamBufferSetControlHandle { 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 StreamBufferSetRequestStream {
    type Item = Result<StreamBufferSetRequest, 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 StreamBufferSetRequestStream 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 {
                    0x3b3a37fc34fe5b56 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetAddPayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetAddPayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamBufferSetControlHandle { inner: this.inner.clone() };
                        Ok(StreamBufferSetRequest::AddPayloadBuffer {
                            id: req.id,
                            payload_buffer: req.payload_buffer,

                            control_handle,
                        })
                    }
                    0x5d1e4f74c3658262 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamBufferSetRemovePayloadBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamBufferSetRemovePayloadBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamBufferSetControlHandle { inner: this.inner.clone() };
                        Ok(StreamBufferSetRequest::RemovePayloadBuffer {
                            id: req.id,

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

/// Manages a set of payload buffers for a stream. This interface is typically
/// inherited along with `StreamSink` or `StreamSource` to enable the transport
/// of elementary streams between clients and services.
#[derive(Debug)]
pub enum StreamBufferSetRequest {
    /// Adds a payload buffer to the current buffer set associated with the
    /// connection. A `StreamPacket` struct reference a payload buffer in the
    /// current set by ID using the `StreamPacket.payload_buffer_id` field.
    ///
    /// A buffer with ID `id` must not be in the current set when this method is
    /// invoked, otherwise the service will close the connection.
    AddPayloadBuffer {
        id: u32,
        payload_buffer: fidl::Vmo,
        control_handle: StreamBufferSetControlHandle,
    },
    /// Removes a payload buffer from the current buffer set associated with the
    /// connection.
    ///
    /// A buffer with ID `id` must exist in the current set when this method is
    /// invoked, otherwise the service will will close the connection.
    RemovePayloadBuffer { id: u32, control_handle: StreamBufferSetControlHandle },
}

impl StreamBufferSetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_payload_buffer(self) -> Option<(u32, fidl::Vmo, StreamBufferSetControlHandle)> {
        if let StreamBufferSetRequest::AddPayloadBuffer { id, payload_buffer, control_handle } =
            self
        {
            Some((id, payload_buffer, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_payload_buffer(self) -> Option<(u32, StreamBufferSetControlHandle)> {
        if let StreamBufferSetRequest::RemovePayloadBuffer { id, control_handle } = self {
            Some((id, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamBufferSetRequest::AddPayloadBuffer { .. } => "add_payload_buffer",
            StreamBufferSetRequest::RemovePayloadBuffer { .. } => "remove_payload_buffer",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for StreamBufferSetControlHandle {
    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 StreamBufferSetControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for StreamProcessorMarker {
    type Proxy = StreamProcessorProxy;
    type RequestStream = StreamProcessorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamProcessorSynchronousProxy;

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

pub trait StreamProcessorProxyInterface: Send + Sync {
    fn r#enable_on_stream_failed(&self) -> Result<(), fidl::Error>;
    fn r#set_input_buffer_partial_settings(
        &self,
        input_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error>;
    fn r#set_output_buffer_partial_settings(
        &self,
        output_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error>;
    fn r#complete_output_buffer_partial_settings(
        &self,
        buffer_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error>;
    fn r#flush_end_of_stream_and_close_stream(
        &self,
        stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error>;
    fn r#close_current_stream(
        &self,
        stream_lifetime_ordinal: u64,
        release_input_buffers: bool,
        release_output_buffers: bool,
    ) -> Result<(), fidl::Error>;
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#recycle_output_packet(
        &self,
        available_output_packet: &PacketHeader,
    ) -> Result<(), fidl::Error>;
    fn r#queue_input_format_details(
        &self,
        stream_lifetime_ordinal: u64,
        format_details: &FormatDetails,
    ) -> Result<(), fidl::Error>;
    fn r#queue_input_packet(&self, packet: &Packet) -> Result<(), fidl::Error>;
    fn r#queue_input_end_of_stream(&self, stream_lifetime_ordinal: u64) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamProcessorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamProcessorSynchronousProxy {
    type Proxy = StreamProcessorProxy;
    type Protocol = StreamProcessorMarker;

    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 StreamProcessorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamProcessorMarker 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<StreamProcessorEvent, fidl::Error> {
        StreamProcessorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Permit the server to use OnStreamFailed() instead of the server just
    /// closing the whole StreamProcessor channel on stream failure.
    ///
    /// If the server hasn't seen this message by the time a stream fails, the
    /// server will close the StreamProcessor channel instead of sending
    /// OnStreamFailed().
    pub fn r#enable_on_stream_failed(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x3940929617dbf02b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This is the replacement for SetInputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetInputBufferSettings()+AddInputBuffer().  Instead, a
    /// single SetInputBufferPartialSettings() provides the StreamProcessor with
    /// the client-specified input settings and a BufferCollectionToken which
    /// the StreamProcessor will use to convey constraints to sysmem.  Both the
    /// client and the StreamProcessor will be informed of the allocated buffers
    /// directly by sysmem via their BufferCollection channel (not via the
    /// StreamProcessor channel).
    ///
    /// The client must not QueueInput...() until after sysmem informs the client
    /// that buffer allocation has completed and was successful.
    ///
    /// The server should be prepared to see QueueInput...() before the server
    /// has necessarily heard from sysmem that the buffers are allocated - the
    /// server must tolerate either ordering, as the QueueInput...() and
    /// notification of sysmem allocation completion arrive on different
    /// channels, so the client having heard that allocation is complete doesn't
    /// mean the server knows that allocation is complete yet.  However, the
    /// server can expect that allocation is in fact complete and can expect to
    /// get the allocation information from sysmem immediately upon requesting
    /// the information from sysmem.
    pub fn r#set_input_buffer_partial_settings(
        &self,
        mut input_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorSetInputBufferPartialSettingsRequest>(
            (&mut input_settings,),
            0xb02e0663a40e4c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This is the replacement for SetOutputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetOutputBufferSettings()+AddOutputBuffer(). Instead, a
    /// single SetOutputBufferPartialSettings() provides the StreamProcessor
    /// with the client-specified output settings and a BufferCollectionToken
    /// which the StreamProcessor will use to convey constraints to sysmem.
    /// Both the client and the StreamProcessor will be informed of the
    /// allocated buffers directly by sysmem via their BufferCollection channel
    /// (not via the StreamProcessor channel).
    ///
    /// Configuring output buffers is _required_ after OnOutputConstraints() is
    /// received by the client with buffer_constraints_action_required true and
    /// stream_lifetime_ordinal equal to the client's current
    /// stream_lifetime_ordinal (even if there is an active stream), and is
    /// _permitted_ any time there is no current stream.
    ///
    /// Closing the current stream occurs on the StreamControl ordering domain,
    /// so after a CloseCurrentStream() or FlushEndOfStreamAndCloseStream(), a
    /// subsequent Sync() completion must be received by the client before the
    /// client knows that there's no longer a current stream.
    ///
    /// See also CompleteOutputBufferPartialSettings().
    pub fn r#set_output_buffer_partial_settings(
        &self,
        mut output_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorSetOutputBufferPartialSettingsRequest>(
            (&mut output_settings,),
            0x118bb8c819a7bbbb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// After SetOutputBufferPartialSettings(), the server won't send
    /// OnOutputConstraints(), OnOutputFormat(), OnOutputPacket(), or
    /// OnOutputEndOfStream() until after the client sends
    /// CompleteOutputBufferPartialSettings().
    ///
    /// Some clients may be able to send
    /// CompleteOutputBufferPartialSettings() immediately after
    /// SetOutputBufferPartialSettings() - in that case the client needs to be
    /// prepared to receive output without knowing the buffer count or packet
    /// count yet - such clients may internally delay processing the received
    /// output until the client has heard from sysmem (which is when the client
    /// will learn the buffer count and packet count).
    ///
    /// Other clients may first wait for sysmem to allocate, prepare to receive
    /// output, and then send CompleteOutputBufferPartialSettings().
    pub fn r#complete_output_buffer_partial_settings(
        &self,
        mut buffer_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
            (buffer_lifetime_ordinal,),
            0x50529e5c680ae3ab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This message is optional.
    ///
    /// This message is only valid after QueueInputEndOfStream() for this stream.
    /// The stream_lifetime_ordinal input parameter must match the
    /// stream_lifetime_ordinal of the QueueInputEndOfStream(), else the server
    /// will close the channel.
    ///
    /// A client can use this message to flush through (not discard) the last
    /// input data of a stream so that the stream processor server generates
    /// corresponding output data for all the input data before the server moves
    /// on to the next stream, without forcing the client to wait for
    /// OnOutputEndOfStream() before queueing data of another stream.
    ///
    /// The difference between QueueInputEndOfStream() and
    /// FlushEndOfStreamAndCloseStream():  QueueInputEndOfStream() is a promise
    /// from the client that there will not be any more input data for the
    /// stream (and this info is needed by some stream processors for the stream
    /// processor to ever emit the very last output data).  The
    /// QueueInputEndOfStream() having been sent doesn't prevent the client from
    /// later completely discarding the rest of the current stream by closing
    /// the current stream (with or without a stream switch).  In contrast,
    /// FlushEndOfStreamAndCloseStream() is a request from the client that all
    /// the previously-queued input data be processed including the logical
    /// "EndOfStream" showing up as OnOutputEndOfStream() (in success case)
    /// before moving on to any newer stream - this essentially changes the
    /// close-stream handling from discard to flush-through for this stream
    /// only.
    ///
    /// A client using this message can start providing input data for a new
    /// stream without that causing discard of old stream data.  That's the
    /// purpose of this message - to allow a client to flush through (not
    /// discard) the old stream's last data (instead of the default when closing
    /// or switching streams which is discard).
    ///
    /// Because the old stream is not done processing yet and the old stream's
    /// data is not being discarded, the client must be prepared to continue to
    /// process OnOutputConstraints() messages until the stream_lifetime_ordinal
    /// is done. The client will know the stream_lifetime_ordinal is done when
    /// OnOutputEndOfStream(), OnStreamFailed(), or the StreamProcessor channel
    /// closes.
    pub fn r#flush_end_of_stream_and_close_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(
            (stream_lifetime_ordinal,),
            0x2b62c3e26d0667e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This "closes" the current stream, leaving no current stream.  In
    /// addition, this message can optionally release input buffers or output
    /// buffers.
    ///
    /// If there has never been any active stream, the stream_lifetime_ordinal
    /// must be zero or the server will close the channel.  If there has been an
    /// active stream, the stream_lifetime_ordinal must be the most recent
    /// active stream whether that stream is still active or not.  Else the
    /// server will close the channel.
    ///
    /// Multiple of this message without any new active stream in between is not
    /// to be considered an error, which allows a client to use this message to
    /// close the current stream to stop wasting processing power on a stream the
    /// user no longer cares about, then later decide that buffers should be
    /// released and send this message again with release_input_buffers and/or
    /// release_output_buffers true to get the buffers released, if the client is
    /// interested in trying to avoid overlap in resource usage between old
    /// buffers and new buffers (not all clients are).
    ///
    /// See also Sync().
    pub fn r#close_current_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut release_input_buffers: bool,
        mut release_output_buffers: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorCloseCurrentStreamRequest>(
            (stream_lifetime_ordinal, release_input_buffers, release_output_buffers),
            0x1d8a67522170ca07,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// On completion, all previous StreamProcessor calls have done what they're
    /// going to do server-side, _except_ for processing of data queued using
    /// QueueInputPacket().
    ///
    /// The main purpose of this call is to enable the client to wait until
    /// CloseCurrentStream() with release_input_buffers and/or
    /// release_output_buffers set to true to take effect, before the client
    /// allocates new buffers and re-sets-up input and/or output buffers.  This
    /// de-overlapping of resource usage can be worthwhile for media buffers
    /// which can consume resource types whose overall pools aren't necessarily
    /// vast in comparison to resources consumed.  Especially if a client is
    /// reconfiguring buffers multiple times.
    ///
    /// Note that Sync() prior to allocating new media buffers is not alone
    /// sufficient to achieve non-overlap of media buffer resource usage system
    /// wide, but it can be a useful part of achieving that.
    ///
    /// The Sync() transits the Output ordering domain and the StreamControl
    /// ordering domain, but not the InputData ordering domain.
    ///
    /// This request can be used to avoid hitting kMaxInFlightStreams which is
    /// presently 10.  A client that stays <= 8 in-flight streams will
    /// comfortably stay under the limit of 10.  While the protocol permits
    /// repeated SetInputBufferSettings() and the like, a client that spams the
    /// channel can expect that the channel will just close if the server or the
    /// channel itself gets too far behind.
    pub fn r#sync(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x4b3e44300b0ec6aa,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// After the client is done with an output packet, the client needs to tell
    /// the stream processor that the output packet can be re-used for more
    /// output, via this method.
    ///
    /// It's not permitted to recycle an output packet that's already free with
    /// the stream processor server.  It's permitted but discouraged for a
    /// client to recycle an output packet that has been deallocated by an
    /// explicit or implicit output buffer de-configuration().  See
    /// buffer_lifetime_ordinal for more on that. A server must ignore any such
    /// stale RecycleOutputPacket() calls.
    pub fn r#recycle_output_packet(
        &self,
        mut available_output_packet: &PacketHeader,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorRecycleOutputPacketRequest>(
            (available_output_packet,),
            0x32763632b94e0bd5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// If the input format details are still the same as specified during
    /// StreamProcessor creation, this message is unnecessary and does not need
    /// to be sent.
    ///
    /// If the stream doesn't exist yet, this message creates the stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// All servers must permit QueueInputFormatDetails() at the start of a
    /// stream without failing, as long as the new format is supported by the
    /// StreamProcessor instance.  Technically this allows for a server to only
    /// support the exact input format set during StreamProcessor creation, and
    /// that is by design.  A client that tries to switch formats and gets a
    /// StreamProcessor channel failure should try again one more time with a
    /// fresh StreamProcessor instance created with CodecFactory using the new
    /// input format during creation, before giving up.
    ///
    /// These format details override the format details specified during stream
    /// processor creation for this stream only.  The next stream will default
    /// back to the format details set during stream processor creation.
    ///
    /// This message is permitted at the start of the first stream (just like at
    /// the start of any stream).  The format specified need not match what was
    /// specified during stream processor creation, but if it doesn't match, the
    /// StreamProcessor channel might close as described above.
    pub fn r#queue_input_format_details(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut format_details: &FormatDetails,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputFormatDetailsRequest>(
            (stream_lifetime_ordinal, format_details),
            0x170dc0979d52231,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This message queues input data to the stream processor for processing.
    ///
    /// If the stream doesn't exist yet, this message creates the new stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// The client must continue to deliver input data via this message even if
    /// the stream processor has not yet generated the first OnOutputConstraints(),
    /// and even if the StreamProcessor is generating OnFreeInputPacket() for
    /// previously-queued input packets.  The input data must continue as long
    /// as there are free packets to be assured that the server will ever
    /// generate the first OnOutputConstraints().
    pub fn r#queue_input_packet(&self, mut packet: &Packet) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputPacketRequest>(
            (packet,),
            0x47173d2652d9df3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Inform the server that all QueueInputPacket() messages for this stream
    /// have been sent.
    ///
    /// If the stream isn't closed first (by the client, or by OnStreamFailed(),
    /// or StreamProcessor channel closing), there will later be a corresponding
    /// OnOutputEndOfStream().
    ///
    /// The corresponding OnOutputEndOfStream() message will be generated only if
    /// the server finishes processing the stream before the server sees the
    /// client close the stream (such as by starting a new stream).  A way to
    /// force the server to finish the stream before closing is to use
    /// FlushEndOfStreamAndCloseStream() after QueueInputEndOfStream() before any
    /// new stream.  Another way to force the server to finish the stream before
    /// closing is to wait for the OnOutputEndOfStream() before taking any action
    /// that closes the stream.
    ///
    /// In addition to serving as an "EndOfStream" marker to make it obvious
    /// client-side when all input data has been processed, if a client never
    /// sends QueueInputEndOfStream(), no amount of waiting will necessarily
    /// result in all input data getting processed through to the output.  Some
    /// stream processors have some internally-delayed data which only gets
    /// pushed through by additional input data _or_ by this EndOfStream marker.
    /// In that sense, this message can be viewed as a flush-through at
    /// InputData domain level, but the flush-through only takes effect if the
    /// stream processor even gets that far before the stream is just closed at
    /// StreamControl domain level.  This message is not alone sufficient to act
    /// as an overall flush-through at StreamControl level. For that, send this
    /// message first and then send FlushEndOfStreamAndCloseStream() (at which
    /// point it becomes possible to queue input data for a new stream without
    /// causing discard of this older stream's data), or wait for the
    /// OnOutputEndOfStream() before closing the current stream.
    ///
    /// If a client sends QueueInputPacket(), QueueInputFormatDetails(),
    /// QueueInputEndOfStream() for this stream after the first
    /// QueueInputEndOfStream() for this stream, a server should close the
    /// StreamProcessor channel.
    pub fn r#queue_input_end_of_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputEndOfStreamRequest>(
            (stream_lifetime_ordinal,),
            0x2051b6ad00f20b37,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StreamProcessorProxy {
    type Protocol = StreamProcessorMarker;

    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 StreamProcessorProxy {
    /// Create a new Proxy for fuchsia.media/StreamProcessor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamProcessorMarker 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) -> StreamProcessorEventStream {
        StreamProcessorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Permit the server to use OnStreamFailed() instead of the server just
    /// closing the whole StreamProcessor channel on stream failure.
    ///
    /// If the server hasn't seen this message by the time a stream fails, the
    /// server will close the StreamProcessor channel instead of sending
    /// OnStreamFailed().
    pub fn r#enable_on_stream_failed(&self) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#enable_on_stream_failed(self)
    }

    /// This is the replacement for SetInputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetInputBufferSettings()+AddInputBuffer().  Instead, a
    /// single SetInputBufferPartialSettings() provides the StreamProcessor with
    /// the client-specified input settings and a BufferCollectionToken which
    /// the StreamProcessor will use to convey constraints to sysmem.  Both the
    /// client and the StreamProcessor will be informed of the allocated buffers
    /// directly by sysmem via their BufferCollection channel (not via the
    /// StreamProcessor channel).
    ///
    /// The client must not QueueInput...() until after sysmem informs the client
    /// that buffer allocation has completed and was successful.
    ///
    /// The server should be prepared to see QueueInput...() before the server
    /// has necessarily heard from sysmem that the buffers are allocated - the
    /// server must tolerate either ordering, as the QueueInput...() and
    /// notification of sysmem allocation completion arrive on different
    /// channels, so the client having heard that allocation is complete doesn't
    /// mean the server knows that allocation is complete yet.  However, the
    /// server can expect that allocation is in fact complete and can expect to
    /// get the allocation information from sysmem immediately upon requesting
    /// the information from sysmem.
    pub fn r#set_input_buffer_partial_settings(
        &self,
        mut input_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#set_input_buffer_partial_settings(self, input_settings)
    }

    /// This is the replacement for SetOutputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetOutputBufferSettings()+AddOutputBuffer(). Instead, a
    /// single SetOutputBufferPartialSettings() provides the StreamProcessor
    /// with the client-specified output settings and a BufferCollectionToken
    /// which the StreamProcessor will use to convey constraints to sysmem.
    /// Both the client and the StreamProcessor will be informed of the
    /// allocated buffers directly by sysmem via their BufferCollection channel
    /// (not via the StreamProcessor channel).
    ///
    /// Configuring output buffers is _required_ after OnOutputConstraints() is
    /// received by the client with buffer_constraints_action_required true and
    /// stream_lifetime_ordinal equal to the client's current
    /// stream_lifetime_ordinal (even if there is an active stream), and is
    /// _permitted_ any time there is no current stream.
    ///
    /// Closing the current stream occurs on the StreamControl ordering domain,
    /// so after a CloseCurrentStream() or FlushEndOfStreamAndCloseStream(), a
    /// subsequent Sync() completion must be received by the client before the
    /// client knows that there's no longer a current stream.
    ///
    /// See also CompleteOutputBufferPartialSettings().
    pub fn r#set_output_buffer_partial_settings(
        &self,
        mut output_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#set_output_buffer_partial_settings(self, output_settings)
    }

    /// After SetOutputBufferPartialSettings(), the server won't send
    /// OnOutputConstraints(), OnOutputFormat(), OnOutputPacket(), or
    /// OnOutputEndOfStream() until after the client sends
    /// CompleteOutputBufferPartialSettings().
    ///
    /// Some clients may be able to send
    /// CompleteOutputBufferPartialSettings() immediately after
    /// SetOutputBufferPartialSettings() - in that case the client needs to be
    /// prepared to receive output without knowing the buffer count or packet
    /// count yet - such clients may internally delay processing the received
    /// output until the client has heard from sysmem (which is when the client
    /// will learn the buffer count and packet count).
    ///
    /// Other clients may first wait for sysmem to allocate, prepare to receive
    /// output, and then send CompleteOutputBufferPartialSettings().
    pub fn r#complete_output_buffer_partial_settings(
        &self,
        mut buffer_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#complete_output_buffer_partial_settings(
            self,
            buffer_lifetime_ordinal,
        )
    }

    /// This message is optional.
    ///
    /// This message is only valid after QueueInputEndOfStream() for this stream.
    /// The stream_lifetime_ordinal input parameter must match the
    /// stream_lifetime_ordinal of the QueueInputEndOfStream(), else the server
    /// will close the channel.
    ///
    /// A client can use this message to flush through (not discard) the last
    /// input data of a stream so that the stream processor server generates
    /// corresponding output data for all the input data before the server moves
    /// on to the next stream, without forcing the client to wait for
    /// OnOutputEndOfStream() before queueing data of another stream.
    ///
    /// The difference between QueueInputEndOfStream() and
    /// FlushEndOfStreamAndCloseStream():  QueueInputEndOfStream() is a promise
    /// from the client that there will not be any more input data for the
    /// stream (and this info is needed by some stream processors for the stream
    /// processor to ever emit the very last output data).  The
    /// QueueInputEndOfStream() having been sent doesn't prevent the client from
    /// later completely discarding the rest of the current stream by closing
    /// the current stream (with or without a stream switch).  In contrast,
    /// FlushEndOfStreamAndCloseStream() is a request from the client that all
    /// the previously-queued input data be processed including the logical
    /// "EndOfStream" showing up as OnOutputEndOfStream() (in success case)
    /// before moving on to any newer stream - this essentially changes the
    /// close-stream handling from discard to flush-through for this stream
    /// only.
    ///
    /// A client using this message can start providing input data for a new
    /// stream without that causing discard of old stream data.  That's the
    /// purpose of this message - to allow a client to flush through (not
    /// discard) the old stream's last data (instead of the default when closing
    /// or switching streams which is discard).
    ///
    /// Because the old stream is not done processing yet and the old stream's
    /// data is not being discarded, the client must be prepared to continue to
    /// process OnOutputConstraints() messages until the stream_lifetime_ordinal
    /// is done. The client will know the stream_lifetime_ordinal is done when
    /// OnOutputEndOfStream(), OnStreamFailed(), or the StreamProcessor channel
    /// closes.
    pub fn r#flush_end_of_stream_and_close_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#flush_end_of_stream_and_close_stream(
            self,
            stream_lifetime_ordinal,
        )
    }

    /// This "closes" the current stream, leaving no current stream.  In
    /// addition, this message can optionally release input buffers or output
    /// buffers.
    ///
    /// If there has never been any active stream, the stream_lifetime_ordinal
    /// must be zero or the server will close the channel.  If there has been an
    /// active stream, the stream_lifetime_ordinal must be the most recent
    /// active stream whether that stream is still active or not.  Else the
    /// server will close the channel.
    ///
    /// Multiple of this message without any new active stream in between is not
    /// to be considered an error, which allows a client to use this message to
    /// close the current stream to stop wasting processing power on a stream the
    /// user no longer cares about, then later decide that buffers should be
    /// released and send this message again with release_input_buffers and/or
    /// release_output_buffers true to get the buffers released, if the client is
    /// interested in trying to avoid overlap in resource usage between old
    /// buffers and new buffers (not all clients are).
    ///
    /// See also Sync().
    pub fn r#close_current_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut release_input_buffers: bool,
        mut release_output_buffers: bool,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#close_current_stream(
            self,
            stream_lifetime_ordinal,
            release_input_buffers,
            release_output_buffers,
        )
    }

    /// On completion, all previous StreamProcessor calls have done what they're
    /// going to do server-side, _except_ for processing of data queued using
    /// QueueInputPacket().
    ///
    /// The main purpose of this call is to enable the client to wait until
    /// CloseCurrentStream() with release_input_buffers and/or
    /// release_output_buffers set to true to take effect, before the client
    /// allocates new buffers and re-sets-up input and/or output buffers.  This
    /// de-overlapping of resource usage can be worthwhile for media buffers
    /// which can consume resource types whose overall pools aren't necessarily
    /// vast in comparison to resources consumed.  Especially if a client is
    /// reconfiguring buffers multiple times.
    ///
    /// Note that Sync() prior to allocating new media buffers is not alone
    /// sufficient to achieve non-overlap of media buffer resource usage system
    /// wide, but it can be a useful part of achieving that.
    ///
    /// The Sync() transits the Output ordering domain and the StreamControl
    /// ordering domain, but not the InputData ordering domain.
    ///
    /// This request can be used to avoid hitting kMaxInFlightStreams which is
    /// presently 10.  A client that stays <= 8 in-flight streams will
    /// comfortably stay under the limit of 10.  While the protocol permits
    /// repeated SetInputBufferSettings() and the like, a client that spams the
    /// channel can expect that the channel will just close if the server or the
    /// channel itself gets too far behind.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        StreamProcessorProxyInterface::r#sync(self)
    }

    /// After the client is done with an output packet, the client needs to tell
    /// the stream processor that the output packet can be re-used for more
    /// output, via this method.
    ///
    /// It's not permitted to recycle an output packet that's already free with
    /// the stream processor server.  It's permitted but discouraged for a
    /// client to recycle an output packet that has been deallocated by an
    /// explicit or implicit output buffer de-configuration().  See
    /// buffer_lifetime_ordinal for more on that. A server must ignore any such
    /// stale RecycleOutputPacket() calls.
    pub fn r#recycle_output_packet(
        &self,
        mut available_output_packet: &PacketHeader,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#recycle_output_packet(self, available_output_packet)
    }

    /// If the input format details are still the same as specified during
    /// StreamProcessor creation, this message is unnecessary and does not need
    /// to be sent.
    ///
    /// If the stream doesn't exist yet, this message creates the stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// All servers must permit QueueInputFormatDetails() at the start of a
    /// stream without failing, as long as the new format is supported by the
    /// StreamProcessor instance.  Technically this allows for a server to only
    /// support the exact input format set during StreamProcessor creation, and
    /// that is by design.  A client that tries to switch formats and gets a
    /// StreamProcessor channel failure should try again one more time with a
    /// fresh StreamProcessor instance created with CodecFactory using the new
    /// input format during creation, before giving up.
    ///
    /// These format details override the format details specified during stream
    /// processor creation for this stream only.  The next stream will default
    /// back to the format details set during stream processor creation.
    ///
    /// This message is permitted at the start of the first stream (just like at
    /// the start of any stream).  The format specified need not match what was
    /// specified during stream processor creation, but if it doesn't match, the
    /// StreamProcessor channel might close as described above.
    pub fn r#queue_input_format_details(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut format_details: &FormatDetails,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#queue_input_format_details(
            self,
            stream_lifetime_ordinal,
            format_details,
        )
    }

    /// This message queues input data to the stream processor for processing.
    ///
    /// If the stream doesn't exist yet, this message creates the new stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// The client must continue to deliver input data via this message even if
    /// the stream processor has not yet generated the first OnOutputConstraints(),
    /// and even if the StreamProcessor is generating OnFreeInputPacket() for
    /// previously-queued input packets.  The input data must continue as long
    /// as there are free packets to be assured that the server will ever
    /// generate the first OnOutputConstraints().
    pub fn r#queue_input_packet(&self, mut packet: &Packet) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#queue_input_packet(self, packet)
    }

    /// Inform the server that all QueueInputPacket() messages for this stream
    /// have been sent.
    ///
    /// If the stream isn't closed first (by the client, or by OnStreamFailed(),
    /// or StreamProcessor channel closing), there will later be a corresponding
    /// OnOutputEndOfStream().
    ///
    /// The corresponding OnOutputEndOfStream() message will be generated only if
    /// the server finishes processing the stream before the server sees the
    /// client close the stream (such as by starting a new stream).  A way to
    /// force the server to finish the stream before closing is to use
    /// FlushEndOfStreamAndCloseStream() after QueueInputEndOfStream() before any
    /// new stream.  Another way to force the server to finish the stream before
    /// closing is to wait for the OnOutputEndOfStream() before taking any action
    /// that closes the stream.
    ///
    /// In addition to serving as an "EndOfStream" marker to make it obvious
    /// client-side when all input data has been processed, if a client never
    /// sends QueueInputEndOfStream(), no amount of waiting will necessarily
    /// result in all input data getting processed through to the output.  Some
    /// stream processors have some internally-delayed data which only gets
    /// pushed through by additional input data _or_ by this EndOfStream marker.
    /// In that sense, this message can be viewed as a flush-through at
    /// InputData domain level, but the flush-through only takes effect if the
    /// stream processor even gets that far before the stream is just closed at
    /// StreamControl domain level.  This message is not alone sufficient to act
    /// as an overall flush-through at StreamControl level. For that, send this
    /// message first and then send FlushEndOfStreamAndCloseStream() (at which
    /// point it becomes possible to queue input data for a new stream without
    /// causing discard of this older stream's data), or wait for the
    /// OnOutputEndOfStream() before closing the current stream.
    ///
    /// If a client sends QueueInputPacket(), QueueInputFormatDetails(),
    /// QueueInputEndOfStream() for this stream after the first
    /// QueueInputEndOfStream() for this stream, a server should close the
    /// StreamProcessor channel.
    pub fn r#queue_input_end_of_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#queue_input_end_of_stream(self, stream_lifetime_ordinal)
    }
}

impl StreamProcessorProxyInterface for StreamProcessorProxy {
    fn r#enable_on_stream_failed(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x3940929617dbf02b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_input_buffer_partial_settings(
        &self,
        mut input_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorSetInputBufferPartialSettingsRequest>(
            (&mut input_settings,),
            0xb02e0663a40e4c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_output_buffer_partial_settings(
        &self,
        mut output_settings: StreamBufferPartialSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorSetOutputBufferPartialSettingsRequest>(
            (&mut output_settings,),
            0x118bb8c819a7bbbb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#complete_output_buffer_partial_settings(
        &self,
        mut buffer_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(
            (buffer_lifetime_ordinal,),
            0x50529e5c680ae3ab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#flush_end_of_stream_and_close_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(
            (stream_lifetime_ordinal,),
            0x2b62c3e26d0667e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#close_current_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut release_input_buffers: bool,
        mut release_output_buffers: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorCloseCurrentStreamRequest>(
            (stream_lifetime_ordinal, release_input_buffers, release_output_buffers),
            0x1d8a67522170ca07,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#recycle_output_packet(
        &self,
        mut available_output_packet: &PacketHeader,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorRecycleOutputPacketRequest>(
            (available_output_packet,),
            0x32763632b94e0bd5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#queue_input_format_details(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut format_details: &FormatDetails,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputFormatDetailsRequest>(
            (stream_lifetime_ordinal, format_details),
            0x170dc0979d52231,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#queue_input_packet(&self, mut packet: &Packet) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputPacketRequest>(
            (packet,),
            0x47173d2652d9df3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#queue_input_end_of_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorQueueInputEndOfStreamRequest>(
            (stream_lifetime_ordinal,),
            0x2051b6ad00f20b37,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum StreamProcessorEvent {
    OnStreamFailed {
        stream_lifetime_ordinal: u64,
        error: StreamError,
    },
    OnInputConstraints {
        input_constraints: StreamBufferConstraints,
    },
    OnOutputConstraints {
        output_config: StreamOutputConstraints,
    },
    OnOutputFormat {
        output_format: StreamOutputFormat,
    },
    OnOutputPacket {
        output_packet: Packet,
        error_detected_before: bool,
        error_detected_during: bool,
    },
    OnOutputEndOfStream {
        stream_lifetime_ordinal: u64,
        error_detected_before: bool,
    },
    OnFreeInputPacket {
        free_input_packet: PacketHeader,
    },
}

impl StreamProcessorEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_stream_failed(self) -> Option<(u64, StreamError)> {
        if let StreamProcessorEvent::OnStreamFailed { stream_lifetime_ordinal, error } = self {
            Some((stream_lifetime_ordinal, error))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_input_constraints(self) -> Option<StreamBufferConstraints> {
        if let StreamProcessorEvent::OnInputConstraints { input_constraints } = self {
            Some((input_constraints))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_output_constraints(self) -> Option<StreamOutputConstraints> {
        if let StreamProcessorEvent::OnOutputConstraints { output_config } = self {
            Some((output_config))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_output_format(self) -> Option<StreamOutputFormat> {
        if let StreamProcessorEvent::OnOutputFormat { output_format } = self {
            Some((output_format))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_output_packet(self) -> Option<(Packet, bool, bool)> {
        if let StreamProcessorEvent::OnOutputPacket {
            output_packet,
            error_detected_before,
            error_detected_during,
        } = self
        {
            Some((output_packet, error_detected_before, error_detected_during))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_output_end_of_stream(self) -> Option<(u64, bool)> {
        if let StreamProcessorEvent::OnOutputEndOfStream {
            stream_lifetime_ordinal,
            error_detected_before,
        } = self
        {
            Some((stream_lifetime_ordinal, error_detected_before))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_free_input_packet(self) -> Option<PacketHeader> {
        if let StreamProcessorEvent::OnFreeInputPacket { free_input_packet } = self {
            Some((free_input_packet))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`StreamProcessorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<StreamProcessorEvent, 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 {
            0x77ccf70bb061cf8e => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnStreamFailedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnStreamFailedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnStreamFailed {
                    stream_lifetime_ordinal: out.stream_lifetime_ordinal,
                    error: out.error,
                }))
            }
            0x211da9966a8ca0 => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnInputConstraintsRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnInputConstraintsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnInputConstraints {
                    input_constraints: out.input_constraints,
                }))
            }
            0x40d8234504c170f3 => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnOutputConstraintsRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnOutputConstraintsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnOutputConstraints { output_config: out.output_config }))
            }
            0x131b77ae120360bc => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnOutputFormatRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnOutputFormatRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnOutputFormat { output_format: out.output_format }))
            }
            0x5c2029be1090ce93 => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnOutputPacketRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnOutputPacketRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnOutputPacket {
                    output_packet: out.output_packet,
                    error_detected_before: out.error_detected_before,
                    error_detected_during: out.error_detected_during,
                }))
            }
            0x3bb65d237cfa50e6 => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnOutputEndOfStreamRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnOutputEndOfStreamRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnOutputEndOfStream {
                    stream_lifetime_ordinal: out.stream_lifetime_ordinal,
                    error_detected_before: out.error_detected_before,
                }))
            }
            0xeef799b28708bbd => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnFreeInputPacketRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorOnFreeInputPacketRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnFreeInputPacket {
                    free_input_packet: out.free_input_packet,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <StreamProcessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for StreamProcessorRequestStream {
    type Protocol = StreamProcessorMarker;
    type ControlHandle = StreamProcessorControlHandle;

    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 {
        StreamProcessorControlHandle { 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 StreamProcessorRequestStream {
    type Item = Result<StreamProcessorRequest, 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 StreamProcessorRequestStream 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 {
                    0x3940929617dbf02b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::EnableOnStreamFailed { control_handle })
                    }
                    0xb02e0663a40e4c4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorSetInputBufferPartialSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorSetInputBufferPartialSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::SetInputBufferPartialSettings {
                            input_settings: req.input_settings,

                            control_handle,
                        })
                    }
                    0x118bb8c819a7bbbb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorSetOutputBufferPartialSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorSetOutputBufferPartialSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::SetOutputBufferPartialSettings {
                            output_settings: req.output_settings,

                            control_handle,
                        })
                    }
                    0x50529e5c680ae3ab => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorCompleteOutputBufferPartialSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorCompleteOutputBufferPartialSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::CompleteOutputBufferPartialSettings {
                            buffer_lifetime_ordinal: req.buffer_lifetime_ordinal,

                            control_handle,
                        })
                    }
                    0x2b62c3e26d0667e6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorFlushEndOfStreamAndCloseStreamRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorFlushEndOfStreamAndCloseStreamRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::FlushEndOfStreamAndCloseStream {
                            stream_lifetime_ordinal: req.stream_lifetime_ordinal,

                            control_handle,
                        })
                    }
                    0x1d8a67522170ca07 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorCloseCurrentStreamRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorCloseCurrentStreamRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::CloseCurrentStream {
                            stream_lifetime_ordinal: req.stream_lifetime_ordinal,
                            release_input_buffers: req.release_input_buffers,
                            release_output_buffers: req.release_output_buffers,

                            control_handle,
                        })
                    }
                    0x4b3e44300b0ec6aa => {
                        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 =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::Sync {
                            responder: StreamProcessorSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x32763632b94e0bd5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorRecycleOutputPacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorRecycleOutputPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::RecycleOutputPacket {
                            available_output_packet: req.available_output_packet,

                            control_handle,
                        })
                    }
                    0x170dc0979d52231 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorQueueInputFormatDetailsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorQueueInputFormatDetailsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::QueueInputFormatDetails {
                            stream_lifetime_ordinal: req.stream_lifetime_ordinal,
                            format_details: req.format_details,

                            control_handle,
                        })
                    }
                    0x47173d2652d9df3b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorQueueInputPacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorQueueInputPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::QueueInputPacket {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x2051b6ad00f20b37 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamProcessorQueueInputEndOfStreamRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamProcessorQueueInputEndOfStreamRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamProcessorControlHandle { inner: this.inner.clone() };
                        Ok(StreamProcessorRequest::QueueInputEndOfStream {
                            stream_lifetime_ordinal: req.stream_lifetime_ordinal,

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

/// Overview of operation:
///
/// 1. Create
///   * create via CodecFactory - see CodecFactory
///   * create via LicenseSession - see LicenseSession
/// 2. Get input constraints
///   * OnInputConstraints() - sent unsolicited by stream processor shortly after
///     stream processor creation.
/// 3. Provide input buffers
///   * SetInputBufferPartialSettings()
/// 4. Deliver input data
///   * QueueInputPacket() + OnFreeInputPacket(), for as long as it takes,
///     possibly working through all input packets repeatedly before...
/// 5. Get output constraints and format
///   * OnOutputConstraints()
///   * This is not sent until after at least one QueueInput* message is sent by
///     the client, even if the underlying processor behind the StreamProcessor
///     doesn't fundamentally need any input data to determine its output
///     constraints.  This server behavior prevents clients taking an incorrect
///     dependency on the output constraints showing up before input is
///     delivered.
///   * A client must tolerate this arriving as late as after substantial input
///     data has been delivered, including lots of input packet recycling via
///     OnFreeInputPacket().
///   * This message can arrive more than once before the first output data.
/// 6. Provide output buffers
///   * SetOutputBufferPartialSettings() / CompleteOutputBufferPartialSettings()
/// 7. Data flows, with optional EndOfStream
///   * OnOutputPacket() / RecycleOutputPacket() / QueueInputPacket() /
///     OnFreeInputPacket() / QueueInputEndOfStream() / OnOutputEndOfStream()
///
/// Semi-trusted StreamProcessor server - SW decoders run in an isolate (with
/// very few capabilities) just in case the decoding SW has a vulnerability
/// which could be used to take over the StreamProcessor server.  Clients of the
/// stream processor interface using decoders and processing streams of separate
/// security contexts, to a greater extent than some other interfaces, need to
/// protect themselves against invalid server behavior, such as double-free of a
/// packet_index and any other invalid server behavior.  Having fed in
/// compressed data of one security context, don't place too much trust in a
/// single StreamProcessor instance to not mix data among any buffers that
/// StreamProcessor server has ever been told about.  Instead, create separate
/// StreamProcessor instances for use by security-separate client-side contexts.
/// While the picture for HW-based decoders looks somewhat different and is out
/// of scope of this paragraph, the client should always use separate
/// StreamProcessor instances for security-separate client-side contexts.
///
/// Descriptions of actions taken by methods of this protocol and the states of
/// things are given as if the methods are synchronously executed by the stream
/// processor server, but in reality, as is typical of FIDL interfaces, the
/// message processing is async.  The states described are to be read as the
/// state from the client's point of view unless otherwise stated.  Events
/// coming back from the server are of course delivered async, and a client that
/// processes more than one stream per StreamProcessor instance needs to care
/// whether a given event is from the current stream vs. some older
/// soon-to-be-gone stream.
///
/// The Sync() method's main purpose is to enable the client to robustly prevent
/// having both old and new buffers allocated in the system at the same time,
/// since media buffers can be significantly large, depending. The Sync() method
/// achieves this by only delivering it's response when all previous calls to
/// the StreamProcessor protocol have actually taken effect in the
/// StreamControl ordering domain. Sync() can also be used to wait for the
/// stream processor server to catch up if there's a possibility that a client
/// might otherwise get too far ahead of the StreamProcessor server, by for
/// example requesting creation of a large number of streams in a row.  It can
/// also be used during debugging to ensure that a stream processor server
/// hasn't gotten stuck.  Calling Sync() is entirely optional and never required
/// for correctness - only potentially required to de-overlap resource usage.
///
/// It's possible to re-use a StreamProcessor instance for another stream, and
/// doing so can sometimes skip over re-allocation of buffers. This can be a
/// useful thing to do for cases like seeking to a new location - at the
/// StreamProcessor interface that can look like switching to a new stream.
#[derive(Debug)]
pub enum StreamProcessorRequest {
    /// Permit the server to use OnStreamFailed() instead of the server just
    /// closing the whole StreamProcessor channel on stream failure.
    ///
    /// If the server hasn't seen this message by the time a stream fails, the
    /// server will close the StreamProcessor channel instead of sending
    /// OnStreamFailed().
    EnableOnStreamFailed { control_handle: StreamProcessorControlHandle },
    /// This is the replacement for SetInputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetInputBufferSettings()+AddInputBuffer().  Instead, a
    /// single SetInputBufferPartialSettings() provides the StreamProcessor with
    /// the client-specified input settings and a BufferCollectionToken which
    /// the StreamProcessor will use to convey constraints to sysmem.  Both the
    /// client and the StreamProcessor will be informed of the allocated buffers
    /// directly by sysmem via their BufferCollection channel (not via the
    /// StreamProcessor channel).
    ///
    /// The client must not QueueInput...() until after sysmem informs the client
    /// that buffer allocation has completed and was successful.
    ///
    /// The server should be prepared to see QueueInput...() before the server
    /// has necessarily heard from sysmem that the buffers are allocated - the
    /// server must tolerate either ordering, as the QueueInput...() and
    /// notification of sysmem allocation completion arrive on different
    /// channels, so the client having heard that allocation is complete doesn't
    /// mean the server knows that allocation is complete yet.  However, the
    /// server can expect that allocation is in fact complete and can expect to
    /// get the allocation information from sysmem immediately upon requesting
    /// the information from sysmem.
    SetInputBufferPartialSettings {
        input_settings: StreamBufferPartialSettings,
        control_handle: StreamProcessorControlHandle,
    },
    /// This is the replacement for SetOutputBufferSettings().
    ///
    /// When the client is using sysmem to allocate buffers, this message is
    /// used instead of SetOutputBufferSettings()+AddOutputBuffer(). Instead, a
    /// single SetOutputBufferPartialSettings() provides the StreamProcessor
    /// with the client-specified output settings and a BufferCollectionToken
    /// which the StreamProcessor will use to convey constraints to sysmem.
    /// Both the client and the StreamProcessor will be informed of the
    /// allocated buffers directly by sysmem via their BufferCollection channel
    /// (not via the StreamProcessor channel).
    ///
    /// Configuring output buffers is _required_ after OnOutputConstraints() is
    /// received by the client with buffer_constraints_action_required true and
    /// stream_lifetime_ordinal equal to the client's current
    /// stream_lifetime_ordinal (even if there is an active stream), and is
    /// _permitted_ any time there is no current stream.
    ///
    /// Closing the current stream occurs on the StreamControl ordering domain,
    /// so after a CloseCurrentStream() or FlushEndOfStreamAndCloseStream(), a
    /// subsequent Sync() completion must be received by the client before the
    /// client knows that there's no longer a current stream.
    ///
    /// See also CompleteOutputBufferPartialSettings().
    SetOutputBufferPartialSettings {
        output_settings: StreamBufferPartialSettings,
        control_handle: StreamProcessorControlHandle,
    },
    /// After SetOutputBufferPartialSettings(), the server won't send
    /// OnOutputConstraints(), OnOutputFormat(), OnOutputPacket(), or
    /// OnOutputEndOfStream() until after the client sends
    /// CompleteOutputBufferPartialSettings().
    ///
    /// Some clients may be able to send
    /// CompleteOutputBufferPartialSettings() immediately after
    /// SetOutputBufferPartialSettings() - in that case the client needs to be
    /// prepared to receive output without knowing the buffer count or packet
    /// count yet - such clients may internally delay processing the received
    /// output until the client has heard from sysmem (which is when the client
    /// will learn the buffer count and packet count).
    ///
    /// Other clients may first wait for sysmem to allocate, prepare to receive
    /// output, and then send CompleteOutputBufferPartialSettings().
    CompleteOutputBufferPartialSettings {
        buffer_lifetime_ordinal: u64,
        control_handle: StreamProcessorControlHandle,
    },
    /// This message is optional.
    ///
    /// This message is only valid after QueueInputEndOfStream() for this stream.
    /// The stream_lifetime_ordinal input parameter must match the
    /// stream_lifetime_ordinal of the QueueInputEndOfStream(), else the server
    /// will close the channel.
    ///
    /// A client can use this message to flush through (not discard) the last
    /// input data of a stream so that the stream processor server generates
    /// corresponding output data for all the input data before the server moves
    /// on to the next stream, without forcing the client to wait for
    /// OnOutputEndOfStream() before queueing data of another stream.
    ///
    /// The difference between QueueInputEndOfStream() and
    /// FlushEndOfStreamAndCloseStream():  QueueInputEndOfStream() is a promise
    /// from the client that there will not be any more input data for the
    /// stream (and this info is needed by some stream processors for the stream
    /// processor to ever emit the very last output data).  The
    /// QueueInputEndOfStream() having been sent doesn't prevent the client from
    /// later completely discarding the rest of the current stream by closing
    /// the current stream (with or without a stream switch).  In contrast,
    /// FlushEndOfStreamAndCloseStream() is a request from the client that all
    /// the previously-queued input data be processed including the logical
    /// "EndOfStream" showing up as OnOutputEndOfStream() (in success case)
    /// before moving on to any newer stream - this essentially changes the
    /// close-stream handling from discard to flush-through for this stream
    /// only.
    ///
    /// A client using this message can start providing input data for a new
    /// stream without that causing discard of old stream data.  That's the
    /// purpose of this message - to allow a client to flush through (not
    /// discard) the old stream's last data (instead of the default when closing
    /// or switching streams which is discard).
    ///
    /// Because the old stream is not done processing yet and the old stream's
    /// data is not being discarded, the client must be prepared to continue to
    /// process OnOutputConstraints() messages until the stream_lifetime_ordinal
    /// is done. The client will know the stream_lifetime_ordinal is done when
    /// OnOutputEndOfStream(), OnStreamFailed(), or the StreamProcessor channel
    /// closes.
    FlushEndOfStreamAndCloseStream {
        stream_lifetime_ordinal: u64,
        control_handle: StreamProcessorControlHandle,
    },
    /// This "closes" the current stream, leaving no current stream.  In
    /// addition, this message can optionally release input buffers or output
    /// buffers.
    ///
    /// If there has never been any active stream, the stream_lifetime_ordinal
    /// must be zero or the server will close the channel.  If there has been an
    /// active stream, the stream_lifetime_ordinal must be the most recent
    /// active stream whether that stream is still active or not.  Else the
    /// server will close the channel.
    ///
    /// Multiple of this message without any new active stream in between is not
    /// to be considered an error, which allows a client to use this message to
    /// close the current stream to stop wasting processing power on a stream the
    /// user no longer cares about, then later decide that buffers should be
    /// released and send this message again with release_input_buffers and/or
    /// release_output_buffers true to get the buffers released, if the client is
    /// interested in trying to avoid overlap in resource usage between old
    /// buffers and new buffers (not all clients are).
    ///
    /// See also Sync().
    CloseCurrentStream {
        stream_lifetime_ordinal: u64,
        release_input_buffers: bool,
        release_output_buffers: bool,
        control_handle: StreamProcessorControlHandle,
    },
    /// On completion, all previous StreamProcessor calls have done what they're
    /// going to do server-side, _except_ for processing of data queued using
    /// QueueInputPacket().
    ///
    /// The main purpose of this call is to enable the client to wait until
    /// CloseCurrentStream() with release_input_buffers and/or
    /// release_output_buffers set to true to take effect, before the client
    /// allocates new buffers and re-sets-up input and/or output buffers.  This
    /// de-overlapping of resource usage can be worthwhile for media buffers
    /// which can consume resource types whose overall pools aren't necessarily
    /// vast in comparison to resources consumed.  Especially if a client is
    /// reconfiguring buffers multiple times.
    ///
    /// Note that Sync() prior to allocating new media buffers is not alone
    /// sufficient to achieve non-overlap of media buffer resource usage system
    /// wide, but it can be a useful part of achieving that.
    ///
    /// The Sync() transits the Output ordering domain and the StreamControl
    /// ordering domain, but not the InputData ordering domain.
    ///
    /// This request can be used to avoid hitting kMaxInFlightStreams which is
    /// presently 10.  A client that stays <= 8 in-flight streams will
    /// comfortably stay under the limit of 10.  While the protocol permits
    /// repeated SetInputBufferSettings() and the like, a client that spams the
    /// channel can expect that the channel will just close if the server or the
    /// channel itself gets too far behind.
    Sync { responder: StreamProcessorSyncResponder },
    /// After the client is done with an output packet, the client needs to tell
    /// the stream processor that the output packet can be re-used for more
    /// output, via this method.
    ///
    /// It's not permitted to recycle an output packet that's already free with
    /// the stream processor server.  It's permitted but discouraged for a
    /// client to recycle an output packet that has been deallocated by an
    /// explicit or implicit output buffer de-configuration().  See
    /// buffer_lifetime_ordinal for more on that. A server must ignore any such
    /// stale RecycleOutputPacket() calls.
    RecycleOutputPacket {
        available_output_packet: PacketHeader,
        control_handle: StreamProcessorControlHandle,
    },
    /// If the input format details are still the same as specified during
    /// StreamProcessor creation, this message is unnecessary and does not need
    /// to be sent.
    ///
    /// If the stream doesn't exist yet, this message creates the stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// All servers must permit QueueInputFormatDetails() at the start of a
    /// stream without failing, as long as the new format is supported by the
    /// StreamProcessor instance.  Technically this allows for a server to only
    /// support the exact input format set during StreamProcessor creation, and
    /// that is by design.  A client that tries to switch formats and gets a
    /// StreamProcessor channel failure should try again one more time with a
    /// fresh StreamProcessor instance created with CodecFactory using the new
    /// input format during creation, before giving up.
    ///
    /// These format details override the format details specified during stream
    /// processor creation for this stream only.  The next stream will default
    /// back to the format details set during stream processor creation.
    ///
    /// This message is permitted at the start of the first stream (just like at
    /// the start of any stream).  The format specified need not match what was
    /// specified during stream processor creation, but if it doesn't match, the
    /// StreamProcessor channel might close as described above.
    QueueInputFormatDetails {
        stream_lifetime_ordinal: u64,
        format_details: FormatDetails,
        control_handle: StreamProcessorControlHandle,
    },
    /// This message queues input data to the stream processor for processing.
    ///
    /// If the stream doesn't exist yet, this message creates the new stream.
    ///
    /// The server won't send OnOutputConstraints() until after the client has
    /// sent at least one QueueInput* message.
    ///
    /// The client must continue to deliver input data via this message even if
    /// the stream processor has not yet generated the first OnOutputConstraints(),
    /// and even if the StreamProcessor is generating OnFreeInputPacket() for
    /// previously-queued input packets.  The input data must continue as long
    /// as there are free packets to be assured that the server will ever
    /// generate the first OnOutputConstraints().
    QueueInputPacket { packet: Packet, control_handle: StreamProcessorControlHandle },
    /// Inform the server that all QueueInputPacket() messages for this stream
    /// have been sent.
    ///
    /// If the stream isn't closed first (by the client, or by OnStreamFailed(),
    /// or StreamProcessor channel closing), there will later be a corresponding
    /// OnOutputEndOfStream().
    ///
    /// The corresponding OnOutputEndOfStream() message will be generated only if
    /// the server finishes processing the stream before the server sees the
    /// client close the stream (such as by starting a new stream).  A way to
    /// force the server to finish the stream before closing is to use
    /// FlushEndOfStreamAndCloseStream() after QueueInputEndOfStream() before any
    /// new stream.  Another way to force the server to finish the stream before
    /// closing is to wait for the OnOutputEndOfStream() before taking any action
    /// that closes the stream.
    ///
    /// In addition to serving as an "EndOfStream" marker to make it obvious
    /// client-side when all input data has been processed, if a client never
    /// sends QueueInputEndOfStream(), no amount of waiting will necessarily
    /// result in all input data getting processed through to the output.  Some
    /// stream processors have some internally-delayed data which only gets
    /// pushed through by additional input data _or_ by this EndOfStream marker.
    /// In that sense, this message can be viewed as a flush-through at
    /// InputData domain level, but the flush-through only takes effect if the
    /// stream processor even gets that far before the stream is just closed at
    /// StreamControl domain level.  This message is not alone sufficient to act
    /// as an overall flush-through at StreamControl level. For that, send this
    /// message first and then send FlushEndOfStreamAndCloseStream() (at which
    /// point it becomes possible to queue input data for a new stream without
    /// causing discard of this older stream's data), or wait for the
    /// OnOutputEndOfStream() before closing the current stream.
    ///
    /// If a client sends QueueInputPacket(), QueueInputFormatDetails(),
    /// QueueInputEndOfStream() for this stream after the first
    /// QueueInputEndOfStream() for this stream, a server should close the
    /// StreamProcessor channel.
    QueueInputEndOfStream {
        stream_lifetime_ordinal: u64,
        control_handle: StreamProcessorControlHandle,
    },
}

impl StreamProcessorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_on_stream_failed(self) -> Option<(StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::EnableOnStreamFailed { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_input_buffer_partial_settings(
        self,
    ) -> Option<(StreamBufferPartialSettings, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::SetInputBufferPartialSettings {
            input_settings,
            control_handle,
        } = self
        {
            Some((input_settings, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_output_buffer_partial_settings(
        self,
    ) -> Option<(StreamBufferPartialSettings, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::SetOutputBufferPartialSettings {
            output_settings,
            control_handle,
        } = self
        {
            Some((output_settings, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_complete_output_buffer_partial_settings(
        self,
    ) -> Option<(u64, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::CompleteOutputBufferPartialSettings {
            buffer_lifetime_ordinal,
            control_handle,
        } = self
        {
            Some((buffer_lifetime_ordinal, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush_end_of_stream_and_close_stream(
        self,
    ) -> Option<(u64, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::FlushEndOfStreamAndCloseStream {
            stream_lifetime_ordinal,
            control_handle,
        } = self
        {
            Some((stream_lifetime_ordinal, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close_current_stream(
        self,
    ) -> Option<(u64, bool, bool, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::CloseCurrentStream {
            stream_lifetime_ordinal,
            release_input_buffers,
            release_output_buffers,
            control_handle,
        } = self
        {
            Some((
                stream_lifetime_ordinal,
                release_input_buffers,
                release_output_buffers,
                control_handle,
            ))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(StreamProcessorSyncResponder)> {
        if let StreamProcessorRequest::Sync { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_recycle_output_packet(
        self,
    ) -> Option<(PacketHeader, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::RecycleOutputPacket {
            available_output_packet,
            control_handle,
        } = self
        {
            Some((available_output_packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_queue_input_format_details(
        self,
    ) -> Option<(u64, FormatDetails, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::QueueInputFormatDetails {
            stream_lifetime_ordinal,
            format_details,
            control_handle,
        } = self
        {
            Some((stream_lifetime_ordinal, format_details, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_queue_input_packet(self) -> Option<(Packet, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::QueueInputPacket { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_queue_input_end_of_stream(self) -> Option<(u64, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::QueueInputEndOfStream {
            stream_lifetime_ordinal,
            control_handle,
        } = self
        {
            Some((stream_lifetime_ordinal, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamProcessorRequest::EnableOnStreamFailed { .. } => "enable_on_stream_failed",
            StreamProcessorRequest::SetInputBufferPartialSettings { .. } => {
                "set_input_buffer_partial_settings"
            }
            StreamProcessorRequest::SetOutputBufferPartialSettings { .. } => {
                "set_output_buffer_partial_settings"
            }
            StreamProcessorRequest::CompleteOutputBufferPartialSettings { .. } => {
                "complete_output_buffer_partial_settings"
            }
            StreamProcessorRequest::FlushEndOfStreamAndCloseStream { .. } => {
                "flush_end_of_stream_and_close_stream"
            }
            StreamProcessorRequest::CloseCurrentStream { .. } => "close_current_stream",
            StreamProcessorRequest::Sync { .. } => "sync",
            StreamProcessorRequest::RecycleOutputPacket { .. } => "recycle_output_packet",
            StreamProcessorRequest::QueueInputFormatDetails { .. } => "queue_input_format_details",
            StreamProcessorRequest::QueueInputPacket { .. } => "queue_input_packet",
            StreamProcessorRequest::QueueInputEndOfStream { .. } => "queue_input_end_of_stream",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for StreamProcessorControlHandle {
    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 StreamProcessorControlHandle {
    pub fn send_on_stream_failed(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut error: StreamError,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnStreamFailedRequest>(
            (stream_lifetime_ordinal, error),
            0,
            0x77ccf70bb061cf8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_input_constraints(
        &self,
        mut input_constraints: &StreamBufferConstraints,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnInputConstraintsRequest>(
            (input_constraints,),
            0,
            0x211da9966a8ca0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_output_constraints(
        &self,
        mut output_config: &StreamOutputConstraints,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnOutputConstraintsRequest>(
            (output_config,),
            0,
            0x40d8234504c170f3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_output_format(
        &self,
        mut output_format: &StreamOutputFormat,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnOutputFormatRequest>(
            (output_format,),
            0,
            0x131b77ae120360bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_output_packet(
        &self,
        mut output_packet: &Packet,
        mut error_detected_before: bool,
        mut error_detected_during: bool,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnOutputPacketRequest>(
            (output_packet, error_detected_before, error_detected_during),
            0,
            0x5c2029be1090ce93,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_output_end_of_stream(
        &self,
        mut stream_lifetime_ordinal: u64,
        mut error_detected_before: bool,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnOutputEndOfStreamRequest>(
            (stream_lifetime_ordinal, error_detected_before),
            0,
            0x3bb65d237cfa50e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_free_input_packet(
        &self,
        mut free_input_packet: &PacketHeader,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnFreeInputPacketRequest>(
            (free_input_packet,),
            0,
            0xeef799b28708bbd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for StreamSinkMarker {
    type Proxy = StreamSinkProxy;
    type RequestStream = StreamSinkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamSinkSynchronousProxy;

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

pub trait StreamSinkProxyInterface: Send + Sync {
    type SendPacketResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#send_packet(&self, packet: &StreamPacket) -> Self::SendPacketResponseFut;
    fn r#send_packet_no_reply(&self, packet: &StreamPacket) -> Result<(), fidl::Error>;
    fn r#end_of_stream(&self) -> Result<(), fidl::Error>;
    type DiscardAllPacketsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut;
    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamSinkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamSinkSynchronousProxy {
    type Proxy = StreamSinkProxy;
    type Protocol = StreamSinkMarker;

    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 StreamSinkSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamSinkMarker 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<StreamSinkEvent, fidl::Error> {
        StreamSinkEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<StreamSinkSendPacketRequest, fidl::encoding::EmptyPayload>(
                (packet,),
                0x67cddd607442775f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x6f4dad7af2917665,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StreamSinkProxy {
    type Protocol = StreamSinkMarker;

    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 StreamSinkProxy {
    /// Create a new Proxy for fuchsia.media/StreamSink.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamSinkMarker 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) -> StreamSinkEventStream {
        StreamSinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet(
        &self,
        mut packet: &StreamPacket,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        StreamSinkProxyInterface::r#send_packet(self, packet)
    }

    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    pub fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        StreamSinkProxyInterface::r#send_packet_no_reply(self, packet)
    }

    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    pub fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        StreamSinkProxyInterface::r#end_of_stream(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    pub fn r#discard_all_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        StreamSinkProxyInterface::r#discard_all_packets(self)
    }

    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        StreamSinkProxyInterface::r#discard_all_packets_no_reply(self)
    }
}

impl StreamSinkProxyInterface for StreamSinkProxy {
    type SendPacketResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        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,
                0x67cddd607442775f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<StreamSinkSendPacketRequest, ()>(
            (packet,),
            0x67cddd607442775f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#send_packet_no_reply(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSinkSendPacketNoReplyRequest>(
            (packet,),
            0x8d9b8b413ceba9d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#end_of_stream(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6180fd6f7e793b71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x50d36d0d23081bc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for StreamSinkRequestStream {
    type Protocol = StreamSinkMarker;
    type ControlHandle = StreamSinkControlHandle;

    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 {
        StreamSinkControlHandle { 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 StreamSinkRequestStream {
    type Item = Result<StreamSinkRequest, 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 StreamSinkRequestStream 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 {
                    0x67cddd607442775f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::SendPacket {
                            packet: req.packet,

                            responder: StreamSinkSendPacketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x8d9b8b413ceba9d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketNoReplyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSinkSendPacketNoReplyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::SendPacketNoReply {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x6180fd6f7e793b71 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::EndOfStream { control_handle })
                    }
                    0x6f4dad7af2917665 => {
                        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 = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::DiscardAllPackets {
                            responder: StreamSinkDiscardAllPacketsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x50d36d0d23081bc4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Consumes a stream of packets. This interface is typically inherited along
/// with `StreamBufferSet` to enable the transport of elementary streams from
/// clients to services.
#[derive(Debug)]
pub enum StreamSinkRequest {
    /// Sends a packet to the service. The response is sent when the service is
    /// done with the associated payload memory.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacket { packet: StreamPacket, responder: StreamSinkSendPacketResponder },
    /// Sends a packet to the service. This interface doesn't define how the
    /// client knows when the sink is done with the associated payload memory.
    /// The inheriting interface must define that.
    ///
    /// `packet` must be valid for the current buffer set, otherwise the service
    /// will close the connection.
    SendPacketNoReply { packet: StreamPacket, control_handle: StreamSinkControlHandle },
    /// Indicates the stream has ended. The precise semantics of this method are
    /// determined by the inheriting interface.
    EndOfStream { control_handle: StreamSinkControlHandle },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released. The response is sent after all packets have been
    /// released.
    DiscardAllPackets { responder: StreamSinkDiscardAllPacketsResponder },
    /// Discards packets previously sent via `SendPacket` or `SendPacketNoReply`
    /// and not yet released.
    DiscardAllPacketsNoReply { control_handle: StreamSinkControlHandle },
}

impl StreamSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet(self) -> Option<(StreamPacket, StreamSinkSendPacketResponder)> {
        if let StreamSinkRequest::SendPacket { packet, responder } = self {
            Some((packet, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_packet_no_reply(self) -> Option<(StreamPacket, StreamSinkControlHandle)> {
        if let StreamSinkRequest::SendPacketNoReply { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_end_of_stream(self) -> Option<(StreamSinkControlHandle)> {
        if let StreamSinkRequest::EndOfStream { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets(self) -> Option<(StreamSinkDiscardAllPacketsResponder)> {
        if let StreamSinkRequest::DiscardAllPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets_no_reply(self) -> Option<(StreamSinkControlHandle)> {
        if let StreamSinkRequest::DiscardAllPacketsNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamSinkRequest::SendPacket { .. } => "send_packet",
            StreamSinkRequest::SendPacketNoReply { .. } => "send_packet_no_reply",
            StreamSinkRequest::EndOfStream { .. } => "end_of_stream",
            StreamSinkRequest::DiscardAllPackets { .. } => "discard_all_packets",
            StreamSinkRequest::DiscardAllPacketsNoReply { .. } => "discard_all_packets_no_reply",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for StreamSinkControlHandle {
    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 StreamSinkControlHandle {}

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for StreamSourceMarker {
    type Proxy = StreamSourceProxy;
    type RequestStream = StreamSourceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamSourceSynchronousProxy;

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

pub trait StreamSourceProxyInterface: Send + Sync {
    fn r#release_packet(&self, packet: &StreamPacket) -> Result<(), fidl::Error>;
    type DiscardAllPacketsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut;
    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamSourceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamSourceSynchronousProxy {
    type Proxy = StreamSourceProxy;
    type Protocol = StreamSourceMarker;

    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 StreamSourceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamSourceMarker 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<StreamSourceEvent, fidl::Error> {
        StreamSourceEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    pub fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSourceReleasePacketRequest>(
            (packet,),
            0x7a7b57f0f7d9e4bb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#discard_all_packets(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x27afd605e97b09d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35f9d721e905b831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StreamSourceProxy {
    type Protocol = StreamSourceMarker;

    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 StreamSourceProxy {
    /// Create a new Proxy for fuchsia.media/StreamSource.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamSourceMarker 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) -> StreamSourceEventStream {
        StreamSourceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    pub fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        StreamSourceProxyInterface::r#release_packet(self, packet)
    }

    pub fn r#discard_all_packets(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        StreamSourceProxyInterface::r#discard_all_packets(self)
    }

    pub fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        StreamSourceProxyInterface::r#discard_all_packets_no_reply(self)
    }
}

impl StreamSourceProxyInterface for StreamSourceProxy {
    fn r#release_packet(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.client.send::<StreamSourceReleasePacketRequest>(
            (packet,),
            0x7a7b57f0f7d9e4bb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#discard_all_packets_no_reply(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x35f9d721e905b831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum StreamSourceEvent {
    OnPacketProduced { packet: StreamPacket },
    OnEndOfStream {},
}

impl StreamSourceEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_packet_produced(self) -> Option<StreamPacket> {
        if let StreamSourceEvent::OnPacketProduced { packet } = self {
            Some((packet))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_end_of_stream(self) -> Option<()> {
        if let StreamSourceEvent::OnEndOfStream {} = self { Some(()) } else { None }
    }

    /// Decodes a message buffer as a [`StreamSourceEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<StreamSourceEvent, 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 {
            0x6bbe69746a3c8bd9 => {
                let mut out = fidl::new_empty!(
                    StreamSourceOnPacketProducedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSourceOnPacketProducedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamSourceEvent::OnPacketProduced { packet: out.packet }))
            }
            0x550e69b41d03e2c2 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamSourceEvent::OnEndOfStream {}))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <StreamSourceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for StreamSourceRequestStream {
    type Protocol = StreamSourceMarker;
    type ControlHandle = StreamSourceControlHandle;

    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 {
        StreamSourceControlHandle { 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 StreamSourceRequestStream {
    type Item = Result<StreamSourceRequest, 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 StreamSourceRequestStream 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 {
                    0x7a7b57f0f7d9e4bb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSourceReleasePacketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSourceReleasePacketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSourceControlHandle { inner: this.inner.clone() };
                        Ok(StreamSourceRequest::ReleasePacket {
                            packet: req.packet,

                            control_handle,
                        })
                    }
                    0x27afd605e97b09d2 => {
                        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 =
                            StreamSourceControlHandle { inner: this.inner.clone() };
                        Ok(StreamSourceRequest::DiscardAllPackets {
                            responder: StreamSourceDiscardAllPacketsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35f9d721e905b831 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 =
                            StreamSourceControlHandle { inner: this.inner.clone() };
                        Ok(StreamSourceRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSourceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Produces a stream of packets. This interface is typically inherited along
/// with `StreamBufferSet` to enable the transport of elementary streams from
/// services to clients.
#[derive(Debug)]
pub enum StreamSourceRequest {
    /// Releases payload memory associated with a packet previously delivered
    /// via `OnPacketProduced`.
    ReleasePacket {
        packet: StreamPacket,
        control_handle: StreamSourceControlHandle,
    },
    DiscardAllPackets {
        responder: StreamSourceDiscardAllPacketsResponder,
    },
    DiscardAllPacketsNoReply {
        control_handle: StreamSourceControlHandle,
    },
}

impl StreamSourceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_release_packet(self) -> Option<(StreamPacket, StreamSourceControlHandle)> {
        if let StreamSourceRequest::ReleasePacket { packet, control_handle } = self {
            Some((packet, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets(self) -> Option<(StreamSourceDiscardAllPacketsResponder)> {
        if let StreamSourceRequest::DiscardAllPackets { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_discard_all_packets_no_reply(self) -> Option<(StreamSourceControlHandle)> {
        if let StreamSourceRequest::DiscardAllPacketsNoReply { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamSourceRequest::ReleasePacket { .. } => "release_packet",
            StreamSourceRequest::DiscardAllPackets { .. } => "discard_all_packets",
            StreamSourceRequest::DiscardAllPacketsNoReply { .. } => "discard_all_packets_no_reply",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for StreamSourceControlHandle {
    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 StreamSourceControlHandle {
    pub fn send_on_packet_produced(&self, mut packet: &StreamPacket) -> Result<(), fidl::Error> {
        self.inner.send::<StreamSourceOnPacketProducedRequest>(
            (packet,),
            0,
            0x6bbe69746a3c8bd9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_end_of_stream(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x550e69b41d03e2c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for Usage2AudioConsumerFactoryMarker {
    type Proxy = Usage2AudioConsumerFactoryProxy;
    type RequestStream = Usage2AudioConsumerFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = Usage2AudioConsumerFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.Usage2AudioConsumerFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for Usage2AudioConsumerFactoryMarker {}

pub trait Usage2AudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        usage: AudioRenderUsage2,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct Usage2AudioConsumerFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for Usage2AudioConsumerFactorySynchronousProxy {
    type Proxy = Usage2AudioConsumerFactoryProxy;
    type Protocol = Usage2AudioConsumerFactoryMarker;

    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 Usage2AudioConsumerFactorySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <Usage2AudioConsumerFactoryMarker 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<Usage2AudioConsumerFactoryEvent, fidl::Error> {
        Usage2AudioConsumerFactoryEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates an `AudioConsumer`, which is an interface for playing audio, given a usage value.
    /// Audio submitted to such a consumer is always rendered locally.
    pub fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage2,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest>(
            (usage, audio_consumer_request),
            0x767722302a171873,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for Usage2AudioConsumerFactoryProxy {
    type Protocol = Usage2AudioConsumerFactoryMarker;

    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 Usage2AudioConsumerFactoryProxy {
    /// Create a new Proxy for fuchsia.media/Usage2AudioConsumerFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <Usage2AudioConsumerFactoryMarker 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) -> Usage2AudioConsumerFactoryEventStream {
        Usage2AudioConsumerFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates an `AudioConsumer`, which is an interface for playing audio, given a usage value.
    /// Audio submitted to such a consumer is always rendered locally.
    pub fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage2,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        Usage2AudioConsumerFactoryProxyInterface::r#create_audio_consumer(
            self,
            usage,
            audio_consumer_request,
        )
    }
}

impl Usage2AudioConsumerFactoryProxyInterface for Usage2AudioConsumerFactoryProxy {
    fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage2,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest>(
            (usage, audio_consumer_request),
            0x767722302a171873,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for Usage2AudioConsumerFactoryRequestStream {
    type Protocol = Usage2AudioConsumerFactoryMarker;
    type ControlHandle = Usage2AudioConsumerFactoryControlHandle;

    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 {
        Usage2AudioConsumerFactoryControlHandle { 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 Usage2AudioConsumerFactoryRequestStream {
    type Item = Result<Usage2AudioConsumerFactoryRequest, 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 Usage2AudioConsumerFactoryRequestStream 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 {
                0x767722302a171873 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(Usage2AudioConsumerFactoryCreateAudioConsumerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = Usage2AudioConsumerFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(Usage2AudioConsumerFactoryRequest::CreateAudioConsumer {usage: req.usage,
audio_consumer_request: req.audio_consumer_request,

                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(Usage2AudioConsumerFactoryRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: Usage2AudioConsumerFactoryControlHandle { 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(Usage2AudioConsumerFactoryRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: Usage2AudioConsumerFactoryControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <Usage2AudioConsumerFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Interface for creating audio consumers for local rendering.
#[derive(Debug)]
pub enum Usage2AudioConsumerFactoryRequest {
    /// Creates an `AudioConsumer`, which is an interface for playing audio, given a usage value.
    /// Audio submitted to such a consumer is always rendered locally.
    CreateAudioConsumer {
        usage: AudioRenderUsage2,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        control_handle: Usage2AudioConsumerFactoryControlHandle,
    },
    /// 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: Usage2AudioConsumerFactoryControlHandle,
        method_type: fidl::MethodType,
    },
}

impl Usage2AudioConsumerFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_consumer(
        self,
    ) -> Option<(
        AudioRenderUsage2,
        fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        Usage2AudioConsumerFactoryControlHandle,
    )> {
        if let Usage2AudioConsumerFactoryRequest::CreateAudioConsumer {
            usage,
            audio_consumer_request,
            control_handle,
        } = self
        {
            Some((usage, audio_consumer_request, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for Usage2AudioConsumerFactoryControlHandle {
    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 Usage2AudioConsumerFactoryControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for UsageAudioConsumerFactoryMarker {
    type Proxy = UsageAudioConsumerFactoryProxy;
    type RequestStream = UsageAudioConsumerFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageAudioConsumerFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageAudioConsumerFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for UsageAudioConsumerFactoryMarker {}

pub trait UsageAudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        usage: AudioRenderUsage,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageAudioConsumerFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageAudioConsumerFactorySynchronousProxy {
    type Proxy = UsageAudioConsumerFactoryProxy;
    type Protocol = UsageAudioConsumerFactoryMarker;

    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 UsageAudioConsumerFactorySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <UsageAudioConsumerFactoryMarker 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<UsageAudioConsumerFactoryEvent, fidl::Error> {
        UsageAudioConsumerFactoryEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(
            (usage, audio_consumer_request),
            0x4d975ca9b8f625a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageAudioConsumerFactoryProxy {
    type Protocol = UsageAudioConsumerFactoryMarker;

    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 UsageAudioConsumerFactoryProxy {
    /// Create a new Proxy for fuchsia.media/UsageAudioConsumerFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <UsageAudioConsumerFactoryMarker 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) -> UsageAudioConsumerFactoryEventStream {
        UsageAudioConsumerFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        UsageAudioConsumerFactoryProxyInterface::r#create_audio_consumer(
            self,
            usage,
            audio_consumer_request,
        )
    }
}

impl UsageAudioConsumerFactoryProxyInterface for UsageAudioConsumerFactoryProxy {
    fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage,
        mut audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(
            (usage, audio_consumer_request),
            0x4d975ca9b8f625a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageAudioConsumerFactoryRequestStream {
    type Protocol = UsageAudioConsumerFactoryMarker;
    type ControlHandle = UsageAudioConsumerFactoryControlHandle;

    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 {
        UsageAudioConsumerFactoryControlHandle { 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 UsageAudioConsumerFactoryRequestStream {
    type Item = Result<UsageAudioConsumerFactoryRequest, 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 UsageAudioConsumerFactoryRequestStream 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 {
                0x4d975ca9b8f625a3 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(UsageAudioConsumerFactoryCreateAudioConsumerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = UsageAudioConsumerFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(UsageAudioConsumerFactoryRequest::CreateAudioConsumer {usage: req.usage,
audio_consumer_request: req.audio_consumer_request,

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

/// Interface for creating audio consumers for local rendering.
#[derive(Debug)]
pub enum UsageAudioConsumerFactoryRequest {
    CreateAudioConsumer {
        usage: AudioRenderUsage,
        audio_consumer_request: fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        control_handle: UsageAudioConsumerFactoryControlHandle,
    },
}

impl UsageAudioConsumerFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_consumer(
        self,
    ) -> Option<(
        AudioRenderUsage,
        fidl::endpoints::ServerEnd<AudioConsumerMarker>,
        UsageAudioConsumerFactoryControlHandle,
    )> {
        if let UsageAudioConsumerFactoryRequest::CreateAudioConsumer {
            usage,
            audio_consumer_request,
            control_handle,
        } = self
        {
            Some((usage, audio_consumer_request, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageAudioConsumerFactoryControlHandle {
    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 UsageAudioConsumerFactoryControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for UsageGainListenerMarker {
    type Proxy = UsageGainListenerProxy;
    type RequestStream = UsageGainListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageGainListenerSynchronousProxy;

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

pub trait UsageGainListenerProxyInterface: Send + Sync {
    type OnGainMuteChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#on_gain_mute_changed(
        &self,
        muted: bool,
        gain_dbfs: f32,
    ) -> Self::OnGainMuteChangedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageGainListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageGainListenerSynchronousProxy {
    type Proxy = UsageGainListenerProxy;
    type Protocol = UsageGainListenerMarker;

    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 UsageGainListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <UsageGainListenerMarker 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<UsageGainListenerEvent, fidl::Error> {
        UsageGainListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called immediately on connection and afterward any time
    /// the usage gain setting changes.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    ///
    /// Note: This API does not have mute reporting implemented; `muted` is always false.
    pub fn r#on_gain_mute_changed(
        &self,
        mut muted: bool,
        mut gain_dbfs: f32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<UsageGainListenerOnGainMuteChangedRequest, fidl::encoding::EmptyPayload>(
                (muted, gain_dbfs),
                0x681570258eac3a8d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageGainListenerProxy {
    type Protocol = UsageGainListenerMarker;

    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 UsageGainListenerProxy {
    /// Create a new Proxy for fuchsia.media/UsageGainListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <UsageGainListenerMarker 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) -> UsageGainListenerEventStream {
        UsageGainListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called immediately on connection and afterward any time
    /// the usage gain setting changes.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    ///
    /// Note: This API does not have mute reporting implemented; `muted` is always false.
    pub fn r#on_gain_mute_changed(
        &self,
        mut muted: bool,
        mut gain_dbfs: f32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        UsageGainListenerProxyInterface::r#on_gain_mute_changed(self, muted, gain_dbfs)
    }
}

impl UsageGainListenerProxyInterface for UsageGainListenerProxy {
    type OnGainMuteChangedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_gain_mute_changed(
        &self,
        mut muted: bool,
        mut gain_dbfs: f32,
    ) -> Self::OnGainMuteChangedResponseFut {
        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,
                0x681570258eac3a8d,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<UsageGainListenerOnGainMuteChangedRequest, ()>(
            (muted, gain_dbfs),
            0x681570258eac3a8d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageGainListenerRequestStream {
    type Protocol = UsageGainListenerMarker;
    type ControlHandle = UsageGainListenerControlHandle;

    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 {
        UsageGainListenerControlHandle { 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 UsageGainListenerRequestStream {
    type Item = Result<UsageGainListenerRequest, 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 UsageGainListenerRequestStream 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 {
                    0x681570258eac3a8d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            UsageGainListenerOnGainMuteChangedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageGainListenerOnGainMuteChangedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageGainListenerControlHandle { inner: this.inner.clone() };
                        Ok(UsageGainListenerRequest::OnGainMuteChanged {
                            muted: req.muted,
                            gain_dbfs: req.gain_dbfs,

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

/// A protocol for watching changes to usage gain settings.
///
/// The channel will close when the device is not present.
#[derive(Debug)]
pub enum UsageGainListenerRequest {
    /// Called immediately on connection and afterward any time
    /// the usage gain setting changes.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    ///
    /// Note: This API does not have mute reporting implemented; `muted` is always false.
    OnGainMuteChanged {
        muted: bool,
        gain_dbfs: f32,
        responder: UsageGainListenerOnGainMuteChangedResponder,
    },
}

impl UsageGainListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_gain_mute_changed(
        self,
    ) -> Option<(bool, f32, UsageGainListenerOnGainMuteChangedResponder)> {
        if let UsageGainListenerRequest::OnGainMuteChanged { muted, gain_dbfs, responder } = self {
            Some((muted, gain_dbfs, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageGainListenerControlHandle {
    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 UsageGainListenerControlHandle {}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for UsageGainReporterMarker {
    type Proxy = UsageGainReporterProxy;
    type RequestStream = UsageGainReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageGainReporterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageGainReporter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for UsageGainReporterMarker {}

pub trait UsageGainReporterProxyInterface: Send + Sync {
    fn r#register_listener(
        &self,
        device_unique_id: &str,
        usage: &Usage,
        usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#register_listener2(
        &self,
        device_unique_id: &str,
        usage: &Usage2,
        usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageGainReporterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageGainReporterSynchronousProxy {
    type Proxy = UsageGainReporterProxy;
    type Protocol = UsageGainReporterMarker;

    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 UsageGainReporterSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <UsageGainReporterMarker 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<UsageGainReporterEvent, fidl::Error> {
        UsageGainReporterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    pub fn r#register_listener(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageGainReporterRegisterListenerRequest>(
            (device_unique_id, usage, usage_gain_listener),
            0x767107c168c226af,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    pub fn r#register_listener2(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage2,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageGainReporterRegisterListener2Request>(
            (device_unique_id, usage, usage_gain_listener),
            0x760a8e1c5873629c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageGainReporterProxy {
    type Protocol = UsageGainReporterMarker;

    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 UsageGainReporterProxy {
    /// Create a new Proxy for fuchsia.media/UsageGainReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <UsageGainReporterMarker 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) -> UsageGainReporterEventStream {
        UsageGainReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    pub fn r#register_listener(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        UsageGainReporterProxyInterface::r#register_listener(
            self,
            device_unique_id,
            usage,
            usage_gain_listener,
        )
    }

    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    pub fn r#register_listener2(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage2,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        UsageGainReporterProxyInterface::r#register_listener2(
            self,
            device_unique_id,
            usage,
            usage_gain_listener,
        )
    }
}

impl UsageGainReporterProxyInterface for UsageGainReporterProxy {
    fn r#register_listener(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageGainReporterRegisterListenerRequest>(
            (device_unique_id, usage, usage_gain_listener),
            0x767107c168c226af,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#register_listener2(
        &self,
        mut device_unique_id: &str,
        mut usage: &Usage2,
        mut usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageGainReporterRegisterListener2Request>(
            (device_unique_id, usage, usage_gain_listener),
            0x760a8e1c5873629c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageGainReporterRequestStream {
    type Protocol = UsageGainReporterMarker;
    type ControlHandle = UsageGainReporterControlHandle;

    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 {
        UsageGainReporterControlHandle { 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 UsageGainReporterRequestStream {
    type Item = Result<UsageGainReporterRequest, 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 UsageGainReporterRequestStream 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 {
                    0x767107c168c226af => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            UsageGainReporterRegisterListenerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageGainReporterRegisterListenerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageGainReporterControlHandle { inner: this.inner.clone() };
                        Ok(UsageGainReporterRequest::RegisterListener {
                            device_unique_id: req.device_unique_id,
                            usage: req.usage,
                            usage_gain_listener: req.usage_gain_listener,

                            control_handle,
                        })
                    }
                    0x760a8e1c5873629c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            UsageGainReporterRegisterListener2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageGainReporterRegisterListener2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageGainReporterControlHandle { inner: this.inner.clone() };
                        Ok(UsageGainReporterRequest::RegisterListener2 {
                            device_unique_id: req.device_unique_id,
                            usage: req.usage,
                            usage_gain_listener: req.usage_gain_listener,

                            control_handle,
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(UsageGainReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: UsageGainReporterControlHandle {
                                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(UsageGainReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: UsageGainReporterControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <UsageGainReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol for setting up watchers of usage gain.
#[derive(Debug)]
pub enum UsageGainReporterRequest {
    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    RegisterListener {
        device_unique_id: String,
        usage: Usage,
        usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
        control_handle: UsageGainReporterControlHandle,
    },
    /// Connects a listener to a stream of usage gain setting changes
    /// for `usage` on the device identified by `device_token`. Usage
    /// Gain is not set directly by any client; it is a translation of
    /// the usage volume setting for each device, summed with active
    /// muting/ducking gain adjustments.
    ///
    /// Devices may map the same volume level to different dbfs, so
    /// a `device_unique_id` is needed to identify the device.
    ///
    /// `AudioDeviceEnumerator` provides programmatic access to devices
    /// and their unique ids if it is necessary for a client to select
    /// an id at runtime.
    RegisterListener2 {
        device_unique_id: String,
        usage: Usage2,
        usage_gain_listener: fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
        control_handle: UsageGainReporterControlHandle,
    },
    /// 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: UsageGainReporterControlHandle,
        method_type: fidl::MethodType,
    },
}

impl UsageGainReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_listener(
        self,
    ) -> Option<(
        String,
        Usage,
        fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
        UsageGainReporterControlHandle,
    )> {
        if let UsageGainReporterRequest::RegisterListener {
            device_unique_id,
            usage,
            usage_gain_listener,
            control_handle,
        } = self
        {
            Some((device_unique_id, usage, usage_gain_listener, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_listener2(
        self,
    ) -> Option<(
        String,
        Usage2,
        fidl::endpoints::ClientEnd<UsageGainListenerMarker>,
        UsageGainReporterControlHandle,
    )> {
        if let UsageGainReporterRequest::RegisterListener2 {
            device_unique_id,
            usage,
            usage_gain_listener,
            control_handle,
        } = self
        {
            Some((device_unique_id, usage, usage_gain_listener, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageGainReporterControlHandle {
    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 UsageGainReporterControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for UsageReporterMarker {
    type Proxy = UsageReporterProxy;
    type RequestStream = UsageReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageReporterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageReporter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for UsageReporterMarker {}

pub trait UsageReporterProxyInterface: Send + Sync {
    fn r#watch(
        &self,
        usage: &Usage,
        usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#watch2(
        &self,
        usage: &Usage2,
        usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageReporterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageReporterSynchronousProxy {
    type Proxy = UsageReporterProxy;
    type Protocol = UsageReporterMarker;

    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 UsageReporterSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <UsageReporterMarker 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<UsageReporterEvent, fidl::Error> {
        UsageReporterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#watch(
        &self,
        mut usage: &Usage,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageReporterWatchRequest>(
            (usage, usage_watcher),
            0x769e6fb17075c959,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#watch2(
        &self,
        mut usage: &Usage2,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageReporterWatch2Request>(
            (usage, usage_watcher),
            0x4a43c4c82f5d8ce8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageReporterProxy {
    type Protocol = UsageReporterMarker;

    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 UsageReporterProxy {
    /// Create a new Proxy for fuchsia.media/UsageReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <UsageReporterMarker 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) -> UsageReporterEventStream {
        UsageReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#watch(
        &self,
        mut usage: &Usage,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        UsageReporterProxyInterface::r#watch(self, usage, usage_watcher)
    }

    pub fn r#watch2(
        &self,
        mut usage: &Usage2,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
    ) -> Result<(), fidl::Error> {
        UsageReporterProxyInterface::r#watch2(self, usage, usage_watcher)
    }
}

impl UsageReporterProxyInterface for UsageReporterProxy {
    fn r#watch(
        &self,
        mut usage: &Usage,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageReporterWatchRequest>(
            (usage, usage_watcher),
            0x769e6fb17075c959,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#watch2(
        &self,
        mut usage: &Usage2,
        mut usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<UsageReporterWatch2Request>(
            (usage, usage_watcher),
            0x4a43c4c82f5d8ce8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageReporterRequestStream {
    type Protocol = UsageReporterMarker;
    type ControlHandle = UsageReporterControlHandle;

    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 {
        UsageReporterControlHandle { 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 UsageReporterRequestStream {
    type Item = Result<UsageReporterRequest, 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 UsageReporterRequestStream 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 {
                    0x769e6fb17075c959 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            UsageReporterWatchRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageReporterWatchRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageReporterControlHandle { inner: this.inner.clone() };
                        Ok(UsageReporterRequest::Watch {
                            usage: req.usage,
                            usage_watcher: req.usage_watcher,

                            control_handle,
                        })
                    }
                    0x4a43c4c82f5d8ce8 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            UsageReporterWatch2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageReporterWatch2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageReporterControlHandle { inner: this.inner.clone() };
                        Ok(UsageReporterRequest::Watch2 {
                            usage: req.usage,
                            usage_watcher: req.usage_watcher,

                            control_handle,
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(UsageReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: UsageReporterControlHandle {
                                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(UsageReporterRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: UsageReporterControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <UsageReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol for setting up watchers of audio usages.
#[derive(Debug)]
pub enum UsageReporterRequest {
    Watch {
        usage: Usage,
        usage_watcher: fidl::endpoints::ClientEnd<UsageWatcherMarker>,
        control_handle: UsageReporterControlHandle,
    },
    Watch2 {
        usage: Usage2,
        usage_watcher: fidl::endpoints::ClientEnd<UsageWatcher2Marker>,
        control_handle: UsageReporterControlHandle,
    },
    /// 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: UsageReporterControlHandle,
        method_type: fidl::MethodType,
    },
}

impl UsageReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(
        self,
    ) -> Option<(Usage, fidl::endpoints::ClientEnd<UsageWatcherMarker>, UsageReporterControlHandle)>
    {
        if let UsageReporterRequest::Watch { usage, usage_watcher, control_handle } = self {
            Some((usage, usage_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch2(
        self,
    ) -> Option<(Usage2, fidl::endpoints::ClientEnd<UsageWatcher2Marker>, UsageReporterControlHandle)>
    {
        if let UsageReporterRequest::Watch2 { usage, usage_watcher, control_handle } = self {
            Some((usage, usage_watcher, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageReporterControlHandle {
    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 UsageReporterControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for UsageWatcherMarker {
    type Proxy = UsageWatcherProxy;
    type RequestStream = UsageWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageWatcherSynchronousProxy;

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

pub trait UsageWatcherProxyInterface: Send + Sync {
    type OnStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#on_state_changed(
        &self,
        usage: &Usage,
        state: &UsageState,
    ) -> Self::OnStateChangedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageWatcherSynchronousProxy {
    type Proxy = UsageWatcherProxy;
    type Protocol = UsageWatcherMarker;

    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 UsageWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <UsageWatcherMarker 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<UsageWatcherEvent, fidl::Error> {
        UsageWatcherEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    pub fn r#on_state_changed(
        &self,
        mut usage: &Usage,
        mut state: &UsageState,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<UsageWatcherOnStateChangedRequest, fidl::encoding::EmptyPayload>(
                (usage, state),
                0x5b955c5768ec75c5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageWatcherProxy {
    type Protocol = UsageWatcherMarker;

    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 UsageWatcherProxy {
    /// Create a new Proxy for fuchsia.media/UsageWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <UsageWatcherMarker 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) -> UsageWatcherEventStream {
        UsageWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    pub fn r#on_state_changed(
        &self,
        mut usage: &Usage,
        mut state: &UsageState,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        UsageWatcherProxyInterface::r#on_state_changed(self, usage, state)
    }
}

impl UsageWatcherProxyInterface for UsageWatcherProxy {
    type OnStateChangedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_state_changed(
        &self,
        mut usage: &Usage,
        mut state: &UsageState,
    ) -> Self::OnStateChangedResponseFut {
        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,
                0x5b955c5768ec75c5,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<UsageWatcherOnStateChangedRequest, ()>(
            (usage, state),
            0x5b955c5768ec75c5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageWatcherRequestStream {
    type Protocol = UsageWatcherMarker;
    type ControlHandle = UsageWatcherControlHandle;

    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 {
        UsageWatcherControlHandle { 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 UsageWatcherRequestStream {
    type Item = Result<UsageWatcherRequest, 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 UsageWatcherRequestStream 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 {
                    0x5b955c5768ec75c5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            UsageWatcherOnStateChangedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageWatcherOnStateChangedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageWatcherControlHandle { inner: this.inner.clone() };
                        Ok(UsageWatcherRequest::OnStateChanged {
                            usage: req.usage,
                            state: req.state,

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

/// A protocol for listening to changes to the policy state of an audio usage.
///
/// User actions, such as lowering the volume or muting a stream, are not reflected in this API.
#[derive(Debug)]
pub enum UsageWatcherRequest {
    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    OnStateChanged {
        usage: Usage,
        state: UsageState,
        responder: UsageWatcherOnStateChangedResponder,
    },
}

impl UsageWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_state_changed(
        self,
    ) -> Option<(Usage, UsageState, UsageWatcherOnStateChangedResponder)> {
        if let UsageWatcherRequest::OnStateChanged { usage, state, responder } = self {
            Some((usage, state, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageWatcherControlHandle {
    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 UsageWatcherControlHandle {}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for UsageWatcher2Marker {
    type Proxy = UsageWatcher2Proxy;
    type RequestStream = UsageWatcher2RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UsageWatcher2SynchronousProxy;

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

pub trait UsageWatcher2ProxyInterface: Send + Sync {
    type OnStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#on_state_changed(
        &self,
        usage: &Usage2,
        state: &UsageState,
    ) -> Self::OnStateChangedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UsageWatcher2SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UsageWatcher2SynchronousProxy {
    type Proxy = UsageWatcher2Proxy;
    type Protocol = UsageWatcher2Marker;

    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 UsageWatcher2SynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <UsageWatcher2Marker 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<UsageWatcher2Event, fidl::Error> {
        UsageWatcher2Event::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    pub fn r#on_state_changed(
        &self,
        mut usage: &Usage2,
        mut state: &UsageState,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<UsageWatcher2OnStateChangedRequest, fidl::encoding::EmptyPayload>(
                (usage, state),
                0xca31a8b13c324d4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UsageWatcher2Proxy {
    type Protocol = UsageWatcher2Marker;

    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 UsageWatcher2Proxy {
    /// Create a new Proxy for fuchsia.media/UsageWatcher2.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <UsageWatcher2Marker 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) -> UsageWatcher2EventStream {
        UsageWatcher2EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    pub fn r#on_state_changed(
        &self,
        mut usage: &Usage2,
        mut state: &UsageState,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        UsageWatcher2ProxyInterface::r#on_state_changed(self, usage, state)
    }
}

impl UsageWatcher2ProxyInterface for UsageWatcher2Proxy {
    type OnStateChangedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_state_changed(
        &self,
        mut usage: &Usage2,
        mut state: &UsageState,
    ) -> Self::OnStateChangedResponseFut {
        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,
                0xca31a8b13c324d4,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<UsageWatcher2OnStateChangedRequest, ()>(
            (usage, state),
            0xca31a8b13c324d4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UsageWatcher2RequestStream {
    type Protocol = UsageWatcher2Marker;
    type ControlHandle = UsageWatcher2ControlHandle;

    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 {
        UsageWatcher2ControlHandle { 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 UsageWatcher2RequestStream {
    type Item = Result<UsageWatcher2Request, 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 UsageWatcher2RequestStream 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 {
                    0xca31a8b13c324d4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            UsageWatcher2OnStateChangedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UsageWatcher2OnStateChangedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            UsageWatcher2ControlHandle { inner: this.inner.clone() };
                        Ok(UsageWatcher2Request::OnStateChanged {
                            usage: req.usage,
                            state: req.state,

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

#[derive(Debug)]
pub enum UsageWatcher2Request {
    /// Called on first connection and whenever the watched usage changes. The provided
    /// usage will always be the bound usage; it is provided so that an implementation of
    /// this protocol may be bound to more than one usage.
    ///
    /// Clients must respond to acknowledge the event. Clients that do not acknowledge their
    /// events will eventually be disconnected.
    OnStateChanged {
        usage: Usage2,
        state: UsageState,
        responder: UsageWatcher2OnStateChangedResponder,
    },
}

impl UsageWatcher2Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_state_changed(
        self,
    ) -> Option<(Usage2, UsageState, UsageWatcher2OnStateChangedResponder)> {
        if let UsageWatcher2Request::OnStateChanged { usage, state, responder } = self {
            Some((usage, state, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for UsageWatcher2ControlHandle {
    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 UsageWatcher2ControlHandle {}

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

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

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

mod internal {
    use super::*;

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

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

    impl fidl::encoding::ResourceTypeMarker for AudioCapturerSetReferenceClockRequest {
        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 AudioCapturerSetReferenceClockRequest {
        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<
            AudioCapturerSetReferenceClockRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioCapturerSetReferenceClockRequest
    {
        #[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::<AudioCapturerSetReferenceClockRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCapturerSetReferenceClockRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.reference_clock,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCapturerSetReferenceClockRequest,
            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::<AudioCapturerSetReferenceClockRequest>(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 AudioCapturerSetReferenceClockRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Clock,
                            { fidl::ObjectType::CLOCK.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!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.reference_clock,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AudioConsumerCreateStreamSinkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioConsumerCreateStreamSinkRequest
    {
        #[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::<AudioConsumerCreateStreamSinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioConsumerCreateStreamSinkRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, 16> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.buffers),
                    <AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),
                    <fidl::encoding::Boxed<Compression> as fidl::encoding::ValueTypeMarker>::borrow(&self.compression),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamSinkMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.stream_sink_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<AudioStreamType, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Boxed<Compression>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamSinkMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioConsumerCreateStreamSinkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[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::<AudioConsumerCreateStreamSinkRequest>(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);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 40, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AudioConsumerCreateStreamSinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffers: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                stream_type: fidl::new_empty!(
                    AudioStreamType,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                compression: fidl::new_empty!(
                    fidl::encoding::Boxed<Compression>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                stream_sink_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamSinkMarker>>,
                    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,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            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 + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.buffers,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                AudioStreamType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.stream_type,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<Compression>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.compression,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<StreamSinkMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.stream_sink_request,
                decoder,
                offset + 40,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for AudioCoreBindUsageVolumeControl2Request {
        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 AudioCoreBindUsageVolumeControl2Request {
        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<
            AudioCoreBindUsageVolumeControl2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioCoreBindUsageVolumeControl2Request
    {
        #[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::<AudioCoreBindUsageVolumeControl2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCoreBindUsageVolumeControl2Request,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.volume_control,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage2, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreBindUsageVolumeControl2Request,
            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::<AudioCoreBindUsageVolumeControl2Request>(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 AudioCoreBindUsageVolumeControl2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage2, fidl::encoding::DefaultFuchsiaResourceDialect),
                volume_control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                    >,
                    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!(
                Usage2,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.volume_control,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for AudioCoreBindUsageVolumeControlRequest {
        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 AudioCoreBindUsageVolumeControlRequest {
        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<
            AudioCoreBindUsageVolumeControlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioCoreBindUsageVolumeControlRequest
    {
        #[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::<AudioCoreBindUsageVolumeControlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCoreBindUsageVolumeControlRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.volume_control,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreBindUsageVolumeControlRequest,
            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::<AudioCoreBindUsageVolumeControlRequest>(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 AudioCoreBindUsageVolumeControlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage, fidl::encoding::DefaultFuchsiaResourceDialect),
                volume_control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                    >,
                    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!(
                Usage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_audio::VolumeControlMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.volume_control,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for AudioCoreCreateAudioCapturerRequest {
        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 AudioCoreCreateAudioCapturerRequest {
        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<
            AudioCoreCreateAudioCapturerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioCoreCreateAudioCapturerRequest
    {
        #[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::<AudioCoreCreateAudioCapturerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioCoreCreateAudioCapturerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.loopback),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_in_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreCreateAudioCapturerRequest,
            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::<AudioCoreCreateAudioCapturerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u32).write_unaligned(0);
            }
            // 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 AudioCoreCreateAudioCapturerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                loopback: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
                audio_in_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AudioCoreCreateAudioCapturerWithConfigurationRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                stream_type: fidl::new_empty!(
                    AudioStreamType,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                configuration: fidl::new_empty!(
                    AudioCapturerConfiguration,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                audio_capturer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                    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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                AudioStreamType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.stream_type,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                AudioCapturerConfiguration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.configuration,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.audio_capturer_request,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for AudioCreateAudioCapturerRequest {
        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 AudioCreateAudioCapturerRequest {
        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<
            AudioCreateAudioCapturerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioCreateAudioCapturerRequest
    {
        #[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::<AudioCreateAudioCapturerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioCreateAudioCapturerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_capturer_request),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.loopback),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            AudioCreateAudioCapturerRequest,
            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::<AudioCreateAudioCapturerRequest>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // 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 AudioCreateAudioCapturerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                audio_capturer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                loopback: fidl::new_empty!(bool, 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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioCapturerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.audio_capturer_request,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.loopback,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for AudioDeviceEnumeratorAddDeviceByChannelRequest {
        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 AudioDeviceEnumeratorAddDeviceByChannelRequest {
        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<
            AudioDeviceEnumeratorAddDeviceByChannelRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioDeviceEnumeratorAddDeviceByChannelRequest
    {
        #[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::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioDeviceEnumeratorAddDeviceByChannelRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.device_name,
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_input),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.channel
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioDeviceEnumeratorAddDeviceByChannelRequest,
            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::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(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)?;
            self.2.encode(encoder, offset + 20, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AudioDeviceEnumeratorAddDeviceByChannelRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_name: fidl::new_empty!(
                    fidl::encoding::BoundedString<256>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                is_input: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
                channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::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.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff00u64;
            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!(
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.device_name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.is_input,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_audio::StreamConfigMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.channel,
                decoder,
                offset + 20,
                _depth
            )?;
            Ok(())
        }
    }

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

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

    impl fidl::encoding::ResourceTypeMarker for AudioRendererSetReferenceClockRequest {
        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 AudioRendererSetReferenceClockRequest {
        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<
            AudioRendererSetReferenceClockRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AudioRendererSetReferenceClockRequest
    {
        #[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::<AudioRendererSetReferenceClockRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioRendererSetReferenceClockRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.reference_clock,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioRendererSetReferenceClockRequest,
            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::<AudioRendererSetReferenceClockRequest>(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 AudioRendererSetReferenceClockRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Clock,
                            { fidl::ObjectType::CLOCK.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!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.reference_clock,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ProfileProviderRegisterHandlerWithCapacityRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProfileProviderRegisterHandlerWithCapacityRequest
    {
        #[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::<ProfileProviderRegisterHandlerWithCapacityRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderRegisterHandlerWithCapacityRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Thread,
                        { fidl::ObjectType::THREAD.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.thread_handle,
                    ),
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.period),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.capacity),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Thread,
                    { fidl::ObjectType::THREAD.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<i64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<f32, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            ProfileProviderRegisterHandlerWithCapacityRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[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::<ProfileProviderRegisterHandlerWithCapacityRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (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)?;
            self.3.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProfileProviderRegisterHandlerWithCapacityRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                period: fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect),
                capacity: fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                i64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.period,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                f32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.capacity,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProfileProviderRegisterMemoryRangeRequest {
        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 ProfileProviderRegisterMemoryRangeRequest {
        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<
            ProfileProviderRegisterMemoryRangeRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProfileProviderRegisterMemoryRangeRequest
    {
        #[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::<ProfileProviderRegisterMemoryRangeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderRegisterMemoryRangeRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Vmar,
                        { fidl::ObjectType::VMAR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vmar_handle
                    ),
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmar,
                    { fidl::ObjectType::VMAR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProfileProviderRegisterMemoryRangeRequest,
            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::<ProfileProviderRegisterMemoryRangeRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProfileProviderRegisterMemoryRangeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProfileProviderUnregisterHandlerRequest {
        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 ProfileProviderUnregisterHandlerRequest {
        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<
            ProfileProviderUnregisterHandlerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProfileProviderUnregisterHandlerRequest
    {
        #[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::<ProfileProviderUnregisterHandlerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderUnregisterHandlerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Thread,
                        { fidl::ObjectType::THREAD.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.thread_handle,
                    ),
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Thread,
                    { fidl::ObjectType::THREAD.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProfileProviderUnregisterHandlerRequest,
            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::<ProfileProviderUnregisterHandlerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProfileProviderUnregisterHandlerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for StreamBufferSetAddPayloadBufferRequest {
        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 StreamBufferSetAddPayloadBufferRequest {
        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<
            StreamBufferSetAddPayloadBufferRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamBufferSetAddPayloadBufferRequest
    {
        #[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::<StreamBufferSetAddPayloadBufferRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                StreamBufferSetAddPayloadBufferRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.payload_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<
            StreamBufferSetAddPayloadBufferRequest,
            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::<StreamBufferSetAddPayloadBufferRequest>(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 StreamBufferSetAddPayloadBufferRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                payload_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.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.payload_buffer, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for Usage2AudioConsumerFactoryCreateAudioConsumerRequest {
        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 Usage2AudioConsumerFactoryCreateAudioConsumerRequest {
        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<
            Usage2AudioConsumerFactoryCreateAudioConsumerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut Usage2AudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[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::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_consumer_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<AudioRenderUsage2, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            Usage2AudioConsumerFactoryCreateAudioConsumerRequest,
            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::<Usage2AudioConsumerFactoryCreateAudioConsumerRequest>(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 Usage2AudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(
                    AudioRenderUsage2,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                audio_consumer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                    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!(
                AudioRenderUsage2,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.audio_consumer_request,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UsageAudioConsumerFactoryCreateAudioConsumerRequest {
        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 UsageAudioConsumerFactoryCreateAudioConsumerRequest {
        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<
            UsageAudioConsumerFactoryCreateAudioConsumerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UsageAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[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::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageAudioConsumerFactoryCreateAudioConsumerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_consumer_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<AudioRenderUsage, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageAudioConsumerFactoryCreateAudioConsumerRequest,
            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::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(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 UsageAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(
                    AudioRenderUsage,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                audio_consumer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                    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!(
                AudioRenderUsage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AudioConsumerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.audio_consumer_request,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            UsageGainReporterRegisterListener2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UsageGainReporterRegisterListener2Request
    {
        #[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::<UsageGainReporterRegisterListener2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageGainReporterRegisterListener2Request, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.device_unique_id),
                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_gain_listener),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<36>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<Usage2, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageGainReporterRegisterListener2Request,
            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::<UsageGainReporterRegisterListener2Request>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UsageGainReporterRegisterListener2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_unique_id: fidl::new_empty!(
                    fidl::encoding::BoundedString<36>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                usage: fidl::new_empty!(Usage2, fidl::encoding::DefaultFuchsiaResourceDialect),
                usage_gain_listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                    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(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<36>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.device_unique_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Usage2,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage_gain_listener,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            UsageGainReporterRegisterListenerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UsageGainReporterRegisterListenerRequest
    {
        #[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::<UsageGainReporterRegisterListenerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageGainReporterRegisterListenerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.device_unique_id),
                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_gain_listener),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<36>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<Usage, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageGainReporterRegisterListenerRequest,
            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::<UsageGainReporterRegisterListenerRequest>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UsageGainReporterRegisterListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_unique_id: fidl::new_empty!(
                    fidl::encoding::BoundedString<36>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                usage: fidl::new_empty!(Usage, fidl::encoding::DefaultFuchsiaResourceDialect),
                usage_gain_listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                    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(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<36>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.device_unique_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Usage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageGainListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage_gain_listener,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UsageReporterWatch2Request {
        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 UsageReporterWatch2Request {
        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<
            UsageReporterWatch2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UsageReporterWatch2Request
    {
        #[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::<UsageReporterWatch2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageReporterWatch2Request, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcher2Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage2, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcher2Marker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageReporterWatch2Request,
            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::<UsageReporterWatch2Request>(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 UsageReporterWatch2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage2, fidl::encoding::DefaultFuchsiaResourceDialect),
                usage_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcher2Marker>>,
                    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!(
                Usage2,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcher2Marker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage_watcher,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UsageReporterWatchRequest {
        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 UsageReporterWatchRequest {
        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<
            UsageReporterWatchRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UsageReporterWatchRequest
    {
        #[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::<UsageReporterWatchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageReporterWatchRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageReporterWatchRequest,
            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::<UsageReporterWatchRequest>(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 UsageReporterWatchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage, fidl::encoding::DefaultFuchsiaResourceDialect),
                usage_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcherMarker>>,
                    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!(
                Usage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<UsageWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.usage_watcher,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl StreamBufferPartialSettings {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.sysmem2_token {
                return 7;
            }
            if let Some(_) = self.sysmem_token {
                return 6;
            }
            if let Some(_) = self.packet_count_for_client {
                return 5;
            }
            if let Some(_) = self.packet_count_for_server {
                return 4;
            }
            if let Some(_) = self.single_buffer_mode {
                return 3;
            }
            if let Some(_) = self.buffer_constraints_version_ordinal {
                return 2;
            }
            if let Some(_) = self.buffer_lifetime_ordinal {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}