fdomain_fuchsia_media/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamBufferPartialSettings {
    /// Each buffer is associated with a `buffer_lifetime_ordinal` value.
    ///
    /// There is a separate buffer_lifetime_ordinal for input vs. output.
    ///
    /// Values must be odd. Values must only increase (increasing by more than 2
    /// is permitted).
    ///
    /// When using `SetInputBufferPartialSettings` or
    /// `SetOutputBufferPartialSettings`, re-use of the same value (considering
    /// input and output separately) for the new message is not allowed. Using
    /// these messages, all the buffers of a given buffer_lifetime_ordinal value
    /// are allocated as one sysmem buffer collection.
    ///
    /// When a new buffer_lifetime_ordinal starts, that also automatically
    /// starts un-registering and releasing any buffers associated with prior
    /// buffer_lifetime_ordinal values, but does not force them to complete
    /// un-registration (or release) if they're still used by the codec for
    /// reference purposes (VP9 can do this across a mid-stream dimensions
    /// switch). A buffer can still be output by the server (as indicated by an
    /// output packet) until un-registration completes.
    ///
    /// If the client wants the server to drop all buffers quickly, the client
    /// can send `CloseCurrentStream` with `release_input_buffers` and/or
    /// `release_output_buffers` set. This of course also stops decode of the
    /// current stream. Closing the `StreamProcessor` client end is another
    /// option.
    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<
        fdomain_client::fidl::ClientEnd<fdomain_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<
        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker>,
    >,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamProcessorAddBufferRequest {
    /// Must be set. Which port (input or output) the buffer is for.
    pub port: Option<Port>,
    /// Typically this is the latest buffer_constraints_version_ordinal
    /// known to the client based on OnInputConstraints/OnOutputConstraints.
    /// Older values are not harmful to correctness.
    ///
    /// The server will ignore this message if the server has already
    /// created a later buffer_constraints_version_ordinal value that has
    /// action_required true. If the server ignores this message, a later
    /// RemoveBuffer for this buffer will complete quickly and without
    /// creating an error.
    ///
    /// A client is not required to ensure that every call to AddBuffer with
    /// the same buffer_lifetime_ordinal uses the same
    /// buffer_constraints_version_ordinal, but the client must ensure that
    /// all buffer_constraints_version_ordinal values which share the same
    /// buffer_lifetime_ordinal are within the same action_required true
    /// interval. Each such interval starts with a value that has
    /// action_required true, and lasts until but not including the next
    /// value with action_required true, or until the current value if there
    /// is not yet a next value with action_required true. If this would
    /// create a problem for a server, that server should set
    /// action_required true instead of false.
    pub buffer_constraints_version_ordinal: Option<u64>,
    /// These values are scoped to input/output separately.
    ///
    /// The first message from the client with a new (higher)
    /// buffer_lifetime_ordinal value begins removing all buffers on the
    /// same port with lower buffer_lifetime_ordinal. However, until removal
    /// is complete, the older buffers can still be used by the codec.
    ///
    /// The AddBuffer message adds the buffer to this
    /// buffer_lifetime_ordinal.
    pub buffer_lifetime_ordinal: Option<u64>,
    /// The buffer_index values under a buffer_lifetime_ordinal must be
    /// unique among all added but not yet fully removed buffers. This value
    /// is initially allocated/specified by the client using this field, and
    /// then both the client and the server will then refer to a this added
    /// buffer uniquely using input vs output, buffer_lifetime_ordinal, and
    /// the buffer_index (all three parts are needed to unambiguously
    /// specify this buffer).
    ///
    /// See RemoveBuffer doc comments for how to safely remove a buffer and
    /// potentially re-use a buffer_index value.
    ///
    /// In contrast to using
    /// SetInputBufferPartialSettings/SetOutputBufferPartialSettings, when
    /// using AddBuffer and RemoveBuffer, the StreamProcessor buffer_index
    /// value has no relation to the sysmem buffer_index (under the sysmem
    /// buffer_collection_id). Instead, the StreamProcessor buffer_index is
    /// specified by this field, not by using sysmem's buffer_index. This
    /// way, two buffers from two sysmem collections having the same sysmem
    /// buffer_index (under separate buffer_collection_id(s)) can be
    /// specified unambiguously in StreamProcessor messages.
    pub buffer_index: Option<u32>,
    /// This is a VMO handle that the server can use to access the sysmem
    /// buffer.
    ///
    /// This VMO is required to have been provided by sysmem, and required
    /// to be compatible with the server's sysmem constraints.
    ///
    /// The buffer_constraints_version_ordinal check occurs first, and
    /// failure of that check just silently ignores the remainder of this
    /// message without checking the buffer field (buffer is just dropped).
    ///
    /// If the buffer_constraints_version_ordinal check passes, but `buffer`
    /// isn't a sysmem-provided VMO or isn't consistent with the server's
    /// sysmem constraints, the server will close the StreamProcessor
    /// server_end. The client can avoid triggering this failure case by
    /// allocating the buffers per the following.
    ///
    /// For video decoder input buffers, the client can allocate the buffer
    /// using sysmem, with participation of this or another instance of the
    /// same codec implementation, using ParticipateInBufferAllocation with
    /// Port.INPUT. The same StreamProcessor instance isn't required
    /// in this case, only the same codec implementation. If using a
    /// different StreamProcessor instance (but still from the same codec
    /// implementation), the client should take care to create the two
    /// StreamProcessor instances with the same requirements specified to
    /// CodecFactory (for example with secure_input_mode and
    /// secure_output_mode set the same way). Video decoder server
    /// implementations with supports_dynamic_buffers true are required to
    /// support allocating input buffers using one StreamProcessor instance
    /// then using them with a different StreamProcessor instance (in
    /// contrast, for output buffers, this is not required).
    ///
    /// For video decoder output buffers, this can be achieved by allocating
    /// the buffer using sysmem, with participation of the same
    /// StreamProcessor instance, using ParticipateInBufferAllocation with
    /// Port.OUTPUT.
    ///
    /// Servers should verify that this VMO is (a) provided by sysmem, and
    /// (b) meets the server's current sysmem constraints. The server can
    /// verify both (a) and (b) by checking the result of sysmem's
    /// CheckVmoConstraints before using this VMO. If that check fails, the
    /// server can close the StreamProcessor server_end.
    pub buffer: Option<fdomain_client::Vmo>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamProcessorParticipateInBufferAllocationRequest {
    /// Which port (input or output) the buffer(s) are for.
    ///
    /// Must be set.
    pub port: Option<Port>,
    /// For input, this field must be set to 1, at least for now.
    ///
    /// For output, this field must set to the latest known (to the client)
    /// buffer_constraints_version_ordinal value from the server. If the
    /// value is less than the latest buffer_constraints_version_ordinal
    /// created by the server which had action_reqiured true, then the
    /// server will set generic sysmem constraints (just min_buffer_count 1)
    /// and otherwise ignore this message. This is intended to allow
    /// allocation to succeed (to allow simpler client error handling for
    /// some clients); in this case a new buffer_constraints_version_ordinal
    /// will reach the client and the client can catch up to the latest.
    ///
    /// If this value is a future value, the server will drop the
    /// sysmem2_token which will cause allocation failure.
    ///
    /// Must be set.
    pub buffer_constraints_version_ordinal: Option<u64>,
    /// This sysmem token is used by the server to inform sysmem directly of
    /// any applicable buffer constraints. These constraints are allowed to
    /// (and in some cases must) depend on how this StreamProcessor instance
    /// was created. For example, secure_input_mode/secure_output_mode
    /// during StreamProcessor creation causes the server to set
    /// secure_required for input/output respectively (as specified by
    /// Port.INPUT or Port.OUTPUT respectively).
    ///
    /// Must be set.
    pub sysmem2_token: Option<
        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker>,
    >,
    /// If set, and there's been at least one AddBuffer previously sent with
    /// this buffer_lifetime_ordinal on the same StreamProcessor instance
    /// which hasn't yet been removed server-side, the new buffer(s) will be
    /// allocated with identical SingleBufferSettings, or fail allocation.
    /// If any of the conditions in this paragraph aren't met, the effect is
    /// the same as if this field is not set.
    ///
    /// If this field is not set, the sysmem constraints set by the server
    /// will be suitable for a buffer of a new buffer_lifetime_ordinal, and
    /// the new buffer's SingleBufferSettings might not match any previous
    /// buffer's SingleBufferSettings.
    ///
    /// If the server has a current stream and `port` indicates the output
    /// port, the constraints set will allow the stream to be correctly
    /// processed across the switch to new buffer_lifetime_ordinal (assuming
    /// the client is using a new buffer_lifetime_ordinal and adds the new
    /// buffer(s) subsequently etc). If port indicates the input port, the
    /// constraints set will be generic for the input port regardless of any
    /// current stream.
    ///
    /// If this mechanism isn't used, the client must still ensure that all
    /// AddBuffer with a given StreamProcessor instance, port, and
    /// buffer_lifetime_ordinal have identical SingleBufferSettings. One way
    /// to do this is to allocate all the buffers of a
    /// buffer_lifetime_ordinal under a single sysmem buffer collection.
    /// Another way is for the client to tell sysmem directly that a new
    /// buffer collection must match the SingleBufferSettings of a prior
    /// collection using
    /// `[fuchsia.sysmem2/BufferCollectionConstraints.must_match_vmo]`
    /// client-side.
    ///
    /// It's not recommended for a client to attempt to force a new
    /// collecton's SingleBufferSettings to match an old collection's
    /// SingleBufferSettings without sysmem's help and without
    /// StreamProcessor's help via this field, because sysmem intentionally
    /// allows clients participating in the same collection to be using
    /// different versions of the sysmem interfaces, so the client may not
    /// have enough information to successfully force the
    /// SingleBufferSettings to match without using `must_match_vmo`, for
    /// example if the client is unaware of a new SingleBufferSettings field
    /// (or similar). The most common StreamProcessor server implementation
    /// (CodecImpl) will handle this field using `must_match_vmo` on behalf
    /// of the client as long as there's still at least one buffer of the
    /// buffer_lifetime_ordinal active in the server. The ability to
    /// dynamically add more buffers to an existing sysmem collection may be
    /// added to sysmem at some point; that would give the client another
    /// way to ensure identical SingleBufferSettings within a
    /// buffer_lifetime_ordinal, but only if/when all sysmem collection
    /// participants indicate support for a dynamic sysmem buffer
    /// collection.
    ///
    /// For output, setting this field is strongly recommended if a client
    /// is adding additional output buffers to an existing
    /// buffer_lifetime_ordinal using a new/different sysmem buffer
    /// collection, and setting this field is recommended for all output
    /// buffer allocations.
    ///
    /// For input, if a client is using the same StreamProcessor instance
    /// for this message and AddBuffer (which is itself recommended when
    /// feasible), use of this field is recommended for those input buffers.
    ///
    /// If set, this value must match the buffer_lifetime_ordinal later sent
    /// in AddBuffer.
    ///
    /// Clients should set this when feasible; see above.
    pub buffer_lifetime_ordinal: Option<u64>,
    /// If set to true, the server will leave all `buffer_count_*` fields
    /// un-set when sending SetConstraints to sysmem, and will set
    /// `min_buffer_count` to 1.
    ///
    /// If un-set or set to false, the server will fill out buffer count
    /// fields when sending SetConstraints to sysmem based on the current
    /// value of `buffer_count_for_server_current`, without any extra slack.
    /// The client can add slack as desired via its own retained token.
    ///
    /// Regardless of whether this field is set to true, it's up to the
    /// client to `AddBuffer` at least `buffer_count_for_server_current`
    /// buffers so that processing can make progress.
    pub allow_single_buffer: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamProcessorRemoveBufferRequest {
    /// Must be set. Which port (input or output) the buffer is for.
    pub port: Option<Port>,
    /// Scoped to input or output, this is the buffer_lifetime_ordinal under
    /// which the buffer_index is meaningful.
    pub buffer_lifetime_ordinal: Option<u64>,
    /// The buffer_index of the buffer previously established (and most
    /// recently established) by AddBuffer, or by
    /// SetInputBufferPartialSettings / SetOutputBufferPartialSettings. The
    /// scope of this value is under input vs. output and under the
    /// buffer_lifetime_ordinal value.
    ///
    /// When using dynamic buffers, the buffer_index values that are between
    /// AddBuffer starting and RemoveBuffer completing (the active
    /// buffer_index values) must be unique for a given Port value and
    /// buffer_lifetime_ordinal value.
    ///
    /// Clients using dynamic buffers may wish to not re-use a buffer_index
    /// value quickly upon completion of RemoveBuffer just to make
    /// debugging/diagnosing easier, but technically re-use of buffer_index
    /// in a subsequent AddBuffer is permitted as soon as RemoveBuffer
    /// completes (from the StreamProcessor point of view - the client may
    /// have its own reasons to not re-use that quickly). AddBuffer under an
    /// old (not current) buffer_lifetime_ordinal is never allowed.
    pub buffer_index: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fdomain_client::fidl::ProtocolMarker for ActivityReporterMarker {
    type Proxy = ActivityReporterProxy;
    type RequestStream = ActivityReporterRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.ActivityReporter";
}
impl fdomain_client::fidl::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, Clone)]
pub struct ActivityReporterProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

impl ActivityReporterProxyInterface for ActivityReporterProxy {
    type WatchRenderActivityResponseFut = fidl::client::QueryResponseFut<
        Vec<AudioRenderUsage>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_render_activity(&self) -> Self::WatchRenderActivityResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioRenderUsage>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ActivityReporterWatchRenderActivityResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_render_activity2(&self) -> Self::WatchRenderActivity2ResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioRenderUsage2>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ActivityReporterWatchRenderActivity2Response>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x484236fc11b363e6,
            >(_buf?)?
            .into_result_fdomain::<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>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_capture_activity(&self) -> Self::WatchCaptureActivityResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioCaptureUsage>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ActivityReporterWatchCaptureActivityResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_capture_activity2(&self) -> Self::WatchCaptureActivity2ResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioCaptureUsage2>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ActivityReporterWatchCaptureActivity2Response>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3d137e0364f9d550,
            >(_buf?)?
            .into_result_fdomain::<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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for AudioMarker {
    type Proxy = AudioProxy;
    type RequestStream = AudioRequestStream;

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

pub trait AudioProxyInterface: Send + Sync {
    fn r#create_audio_renderer(
        &self,
        audio_renderer_request: fdomain_client::fidl::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer(
        &self,
        audio_capturer_request: fdomain_client::fidl::ServerEnd<AudioCapturerMarker>,
        loopback: bool,
    ) -> Result<(), fidl::Error>;
}

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

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

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

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

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

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

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

    pub fn r#create_audio_renderer(
        &self,
        mut audio_renderer_request: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug)]
pub enum AudioRequest {
    CreateAudioRenderer {
        audio_renderer_request: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<AudioCapturerMarker>,
        loopback: bool,
        control_handle: AudioControlHandle,
    },
}

impl AudioRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_renderer(
        self,
    ) -> Option<(fdomain_client::fidl::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<(fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl AudioControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for AudioCapturerMarker {
    type Proxy = AudioCapturerProxy;
    type RequestStream = AudioCapturerRequestStream;

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

pub trait AudioCapturerProxyInterface: Send + Sync {
    fn r#add_payload_buffer(
        &self,
        id: u32,
        payload_buffer: fdomain_client::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: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    type GetReferenceClockResponseFut: std::future::Future<Output = Result<fdomain_client::Clock, fidl::Error>>
        + Send;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut;
    fn r#set_reference_clock(
        &self,
        reference_clock: Option<fdomain_client::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, Clone)]
pub struct AudioCapturerProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

impl AudioCapturerProxyInterface for AudioCapturerProxy {
    fn r#add_payload_buffer(
        &self,
        mut id: u32,
        mut payload_buffer: fdomain_client::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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#capture_at(
        &self,
        mut payload_buffer_id: u32,
        mut payload_offset: u32,
        mut frames: u32,
    ) -> Self::CaptureAtResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamPacket, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCapturerCaptureAtResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#stop_async_capture(&self) -> Self::StopAsyncCaptureResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_media_audio::GainControlMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AudioCapturerBindGainControlRequest>(
            (gain_control_request,),
            0x658a6a17ddb3a8e0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fdomain_client::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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_stream_type(&self) -> Self::GetStreamTypeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamType, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCapturerGetStreamTypeResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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: fdomain_client::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: fdomain_client::Clock,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(reference_clock);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut reference_clock: fdomain_client::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for AudioConsumerMarker {
    type Proxy = AudioConsumerProxy;
    type RequestStream = AudioConsumerRequestStream;

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

pub trait AudioConsumerProxyInterface: Send + Sync {
    fn r#create_stream_sink(
        &self,
        buffers: Vec<fdomain_client::Vmo>,
        stream_type: &AudioStreamType,
        compression: Option<&Compression>,
        stream_sink_request: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_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, Clone)]
pub struct AudioConsumerProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<fdomain_client::Vmo>,
        mut stream_type: &AudioStreamType,
        mut compression: Option<&Compression>,
        mut stream_sink_request: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        AudioConsumerProxyInterface::r#watch_status(self)
    }
}

impl AudioConsumerProxyInterface for AudioConsumerProxy {
    fn r#create_stream_sink(
        &self,
        mut buffers: Vec<fdomain_client::Vmo>,
        mut stream_type: &AudioStreamType,
        mut compression: Option<&Compression>,
        mut stream_sink_request: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_status(&self) -> Self::WatchStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AudioConsumerStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioConsumerWatchStatusResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x525b3b97fdf7d884 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AudioConsumerCreateStreamSinkRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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 fdomain_client::fidl::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<fdomain_client::Vmo>,
        stream_type: AudioStreamType,
        compression: Option<Box<Compression>>,
        stream_sink_request: fdomain_client::fidl::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:
            fdomain_client::fidl::ServerEnd<fdomain_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<fdomain_client::Vmo>,
        AudioStreamType,
        Option<Box<Compression>>,
        fdomain_client::fidl::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<(
        fdomain_client::fidl::ServerEnd<fdomain_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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for AudioCoreMarker {
    type Proxy = AudioCoreProxy;
    type RequestStream = AudioCoreRequestStream;

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

pub trait AudioCoreProxyInterface: Send + Sync {
    fn r#create_audio_renderer(
        &self,
        audio_out_request: fdomain_client::fidl::ServerEnd<AudioRendererMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer_with_configuration(
        &self,
        stream_type: &AudioStreamType,
        configuration: &AudioCapturerConfiguration,
        audio_capturer_request: fdomain_client::fidl::ServerEnd<AudioCapturerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_audio_capturer(
        &self,
        loopback: bool,
        audio_in_request: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_media_audio::VolumeControlMarker,
        >,
    ) -> Result<(), fidl::Error>;
    fn r#bind_usage_volume_control2(
        &self,
        usage: &Usage2,
        volume_control: fdomain_client::fidl::ServerEnd<
            fdomain_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, Clone)]
pub struct AudioCoreProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_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: fdomain_client::fidl::ServerEnd<
            fdomain_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, fdomain_client::fidl::FDomainResourceDialect> {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<
            fdomain_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: fdomain_client::fidl::ServerEnd<
            fdomain_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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_volume_from_db(
        &self,
        mut usage: &Usage,
        mut gain_db: f32,
    ) -> Self::GetVolumeFromDbResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCoreGetVolumeFromDbResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_volume_from_db2(
        &self,
        mut usage: &Usage2,
        mut gain_db: f32,
    ) -> Self::GetVolumeFromDb2ResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AudioCoreGetVolumeFromDb2Response>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x165c811091ef99da,
            >(_buf?)?
            .into_result_fdomain::<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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_db_from_volume(
        &self,
        mut usage: &Usage,
        mut volume: f32,
    ) -> Self::GetDbFromVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioCoreGetDbFromVolumeResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_db_from_volume2(
        &self,
        mut usage: &Usage2,
        mut volume: f32,
    ) -> Self::GetDbFromVolume2ResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<f32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AudioCoreGetDbFromVolume2Response>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5f421a8ebf265bf3,
            >(_buf?)?
            .into_result_fdomain::<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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug)]
pub enum AudioCoreRequest {
    /// Creates an AudioRenderer which outputs audio to the default device.
    CreateAudioRenderer {
        audio_out_request: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_media_audio::VolumeControlMarker>,
        control_handle: AudioCoreControlHandle,
    },
    /// Binds to a volume control protocol for the given usage.
    BindUsageVolumeControl2 {
        usage: Usage2,
        volume_control:
            fdomain_client::fidl::ServerEnd<fdomain_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<(fdomain_client::fidl::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,
        fdomain_client::fidl::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, fdomain_client::fidl::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,
        fdomain_client::fidl::ServerEnd<fdomain_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,
        fdomain_client::fidl::ServerEnd<fdomain_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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for AudioDeviceEnumeratorMarker {
    type Proxy = AudioDeviceEnumeratorProxy;
    type RequestStream = AudioDeviceEnumeratorRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.AudioDeviceEnumerator";
}
impl fdomain_client::fidl::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: fdomain_client::fidl::ClientEnd<
            fdomain_fuchsia_hardware_audio::StreamConfigMarker,
        >,
    ) -> Result<(), fidl::Error>;
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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: fdomain_client::fidl::ClientEnd<
            fdomain_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>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_devices(&self) -> Self::GetDevicesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<AudioDeviceInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioDeviceEnumeratorGetDevicesResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_device_gain(&self, mut device_token: u64) -> Self::GetDeviceGainResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(u64, AudioGainInfo), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioDeviceEnumeratorGetDeviceGainResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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: fdomain_client::fidl::ClientEnd<
            fdomain_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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AudioDeviceEnumeratorOnDeviceAddedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((
                    AudioDeviceEnumeratorEvent::OnDeviceAdded {device: out.device,

                    }
                ))
            }
            0x6f3b7574463d9ff8 => {
                let mut out = fidl::new_empty!(AudioDeviceEnumeratorOnDeviceRemovedRequest, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            })
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for AudioRendererMarker {
    type Proxy = AudioRendererProxy;
    type RequestStream = AudioRendererRequestStream;

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

pub trait AudioRendererProxyInterface: Send + Sync {
    fn r#add_payload_buffer(
        &self,
        id: u32,
        payload_buffer: fdomain_client::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: fdomain_client::fidl::ServerEnd<
            fdomain_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<fdomain_client::Clock, fidl::Error>>
        + Send;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut;
    fn r#set_reference_clock(
        &self,
        reference_clock: Option<fdomain_client::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, Clone)]
pub struct AudioRendererProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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: fdomain_client::fidl::ServerEnd<
            fdomain_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<
        fdomain_client::Clock,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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<fdomain_client::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, fdomain_client::fidl::FDomainResourceDialect> {
        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), fdomain_client::fidl::FDomainResourceDialect>
    {
        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), fdomain_client::fidl::FDomainResourceDialect>
    {
        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: fdomain_client::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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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: fdomain_client::fidl::ServerEnd<
            fdomain_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<
        fdomain_client::Clock,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_reference_clock(&self) -> Self::GetReferenceClockResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Clock, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererGetReferenceClockResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2f7a7f011a172f7e,
            >(_buf?)?;
            Ok(_response.reference_clock)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Clock>(
            (),
            0x2f7a7f011a172f7e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_reference_clock(
        &self,
        mut reference_clock: Option<fdomain_client::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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_min_lead_time(&self) -> Self::GetMinLeadTimeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererGetMinLeadTimeResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#play(&self, mut reference_time: i64, mut media_time: i64) -> Self::PlayResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererPlayResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#pause(&self) -> Self::PauseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AudioRendererPauseResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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: fdomain_client::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: fdomain_client::Clock,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(reference_clock);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut reference_clock: fdomain_client::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for ProfileProviderMarker {
    type Proxy = ProfileProviderProxy;
    type RequestStream = ProfileProviderRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.ProfileProvider";
}
impl fdomain_client::fidl::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: fdomain_client::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: fdomain_client::Thread,
        name: &str,
    ) -> Self::UnregisterHandlerResponseFut;
    type RegisterMemoryRangeResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#register_memory_range(
        &self,
        vmar_handle: fdomain_client::Vmar,
        name: &str,
    ) -> Self::RegisterMemoryRangeResponseFut;
    type UnregisterMemoryRangeResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#unregister_memory_range(
        &self,
        vmar_handle: fdomain_client::Vmar,
    ) -> Self::UnregisterMemoryRangeResponseFut;
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::Thread,
        mut name: &str,
        mut period: i64,
        mut capacity: f32,
    ) -> fidl::client::QueryResponseFut<(i64, i64), fdomain_client::fidl::FDomainResourceDialect>
    {
        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: fdomain_client::Thread,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        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: fdomain_client::Vmar,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        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: fdomain_client::Vmar,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        ProfileProviderProxyInterface::r#unregister_memory_range(self, vmar_handle)
    }
}

impl ProfileProviderProxyInterface for ProfileProviderProxy {
    type RegisterHandlerWithCapacityResponseFut =
        fidl::client::QueryResponseFut<(i64, i64), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#register_handler_with_capacity(
        &self,
        mut thread_handle: fdomain_client::Thread,
        mut name: &str,
        mut period: i64,
        mut capacity: f32,
    ) -> Self::RegisterHandlerWithCapacityResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i64, i64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ProfileProviderRegisterHandlerWithCapacityResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#unregister_handler(
        &self,
        mut thread_handle: fdomain_client::Thread,
        mut name: &str,
    ) -> Self::UnregisterHandlerResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#register_memory_range(
        &self,
        mut vmar_handle: fdomain_client::Vmar,
        mut name: &str,
    ) -> Self::RegisterMemoryRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#unregister_memory_range(
        &self,
        mut vmar_handle: fdomain_client::Vmar,
    ) -> Self::UnregisterMemoryRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x60459ecef7458176 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ProfileProviderRegisterHandlerWithCapacityRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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: fdomain_client::Thread,
        name: String,
        period: i64,
        capacity: f32,
        responder: ProfileProviderRegisterHandlerWithCapacityResponder,
    },
    /// Reset a thread's scheduling profile to the default.
    UnregisterHandler {
        thread_handle: fdomain_client::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: fdomain_client::Vmar,
        name: String,
        responder: ProfileProviderRegisterMemoryRangeResponder,
    },
    /// Reset a memory range's memory profile.
    UnregisterMemoryRange {
        vmar_handle: fdomain_client::Vmar,
        responder: ProfileProviderUnregisterMemoryRangeResponder,
    },
}

impl ProfileProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_handler_with_capacity(
        self,
    ) -> Option<(
        fdomain_client::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<(fdomain_client::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<(fdomain_client::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<(fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for SessionAudioConsumerFactoryMarker {
    type Proxy = SessionAudioConsumerFactoryProxy;
    type RequestStream = SessionAudioConsumerFactoryRequestStream;

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

pub trait SessionAudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        session_id: u64,
        audio_consumer_request: fdomain_client::fidl::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl SessionAudioConsumerFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_consumer(
        self,
    ) -> Option<(
        u64,
        fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl SessionAudioConsumerFactoryControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for SimpleStreamSinkMarker {
    type Proxy = SimpleStreamSinkProxy;
    type RequestStream = SimpleStreamSinkRequestStream;

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

pub trait SimpleStreamSinkProxyInterface: Send + Sync {
    fn r#add_payload_buffer(
        &self,
        id: u32,
        payload_buffer: fdomain_client::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, Clone)]
pub struct SimpleStreamSinkProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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: fdomain_client::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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for SimpleStreamSinkRequestStream {
    type Protocol = SimpleStreamSinkMarker;
    type ControlHandle = SimpleStreamSinkControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x3b3a37fc34fe5b56 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(StreamBufferSetAddPayloadBufferRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SimpleStreamSinkControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SimpleStreamSinkRequest::DiscardAllPacketsNoReply {
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <SimpleStreamSinkMarker as fdomain_client::fidl::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: fdomain_client::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, fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for StreamBufferSetMarker {
    type Proxy = StreamBufferSetProxy;
    type RequestStream = StreamBufferSetRequestStream;

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

pub trait StreamBufferSetProxyInterface: Send + Sync {
    fn r#add_payload_buffer(
        &self,
        id: u32,
        payload_buffer: fdomain_client::Vmo,
    ) -> Result<(), fidl::Error>;
    fn r#remove_payload_buffer(&self, id: u32) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for StreamBufferSetProxy {
    type Protocol = StreamBufferSetMarker;

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for StreamBufferSetRequestStream {
    type Protocol = StreamBufferSetMarker;
    type ControlHandle = StreamBufferSetControlHandle;

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

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

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

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

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

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

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

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

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

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

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

impl StreamBufferSetControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for StreamProcessorMarker {
    type Proxy = StreamProcessorProxy;
    type RequestStream = StreamProcessorRequestStream;

    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>;
    fn r#participate_in_buffer_allocation(
        &self,
        payload: StreamProcessorParticipateInBufferAllocationRequest,
    ) -> Result<(), fidl::Error>;
    fn r#add_buffer(&self, payload: StreamProcessorAddBufferRequest) -> Result<(), fidl::Error>;
    type RemoveBufferResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#remove_buffer(
        &self,
        payload: StreamProcessorRemoveBufferRequest,
    ) -> Self::RemoveBufferResponseFut;
    fn r#enable_old_output_buffers(&self) -> Result<(), fidl::Error>;
    fn r#enable_same_output_buffer_concurrently_in_flight(&self) -> Result<(), fidl::Error>;
    fn r#enable_force_output_buffers_fixed_image_size(&self) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for StreamProcessorProxy {
    type Protocol = StreamProcessorMarker;

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

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

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

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

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

    /// When the client is not using dynamic buffers, 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.
    ///
    /// Mixing of AddBuffer and SetInputBufferPartialSettings is not allowed
    /// while there are any buffers still active on the port. To successfully
    /// switch modes for a port, most clients will want to just start over with
    /// a new StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially within the same StreamProcessor.
    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.
    ///
    /// Mixing of AddBuffer and SetOutputBufferPartialSettings is not allowed
    /// while there are any buffers still active on the port. To successfully
    /// switch modes for a port, most clients will want to just start over with
    /// a new StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially not within the same StreamProcessor instance.
    ///
    /// 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().
    ///
    /// This message isn't permitted after AddBuffer. When using dynamic buffers
    /// the server can send OnOutputConstraints, OnOutputFormat, OnOutputPacket,
    /// or OnOutputEndOfStream at any time after the first QueueInputPacket. In
    /// the case of OnOutputPacket there must also be at least one output buffer
    /// that's been added but not yet fully removed (RemoveBuffer not yet
    /// complete).
    ///
    /// 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; a client isn't required to send this ever.
    ///
    /// Terminology note: In the name of this message, "flush" means flush
    /// through, sometimes called "drain". This messge does not discard. To
    /// discard, just QueueInputPacket with a new stream_lifetime_ordinal
    /// without first waiting for OnOutputEndOfStream of the old stream and
    /// without sending FlushEndOfStreamAndCloseStream.
    ///
    /// There is currently no way to cancel the flush effect of this message
    /// short of the client closing the StreamProcessor channel.
    ///
    /// 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 (drain, 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 (and unregister) 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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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, using this message.
    ///
    /// It's not permitted to recycle an output packet that's already free with
    /// the stream processor server.
    ///
    /// If a client is using EnableOldOutputBuffers, the client must recycle all
    /// packets when done with them, even those of old buffer_lifetime_ordinal.
    /// This is also permitted behavior for all clients.
    ///
    /// If a client is not using EnableOldOutputBuffers, the client may
    /// optionally omit this message for packets with an old
    /// buffer_lifetime_ordinal. In other words, packets from before an explicit
    /// or implicit output buffer de-configuration don't need to be recycled if
    /// the client isn't using and won't be using EnableOldOutputBuffers.
    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.
    ///
    /// When using dynamic buffers the server can send OnOutputConstraints,
    /// OnOutputFormat, OnOutputPacket, or OnOutputEndOfStream at any time after
    /// the first QueueInputPacket. In the case of OnOutputPacket there must
    /// also be at least one output buffer that's been added but not yet fully
    /// removed (RemoveBuffer not yet complete).
    ///
    /// 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.
    ///
    /// The server will close the channel if this packet refers to an old
    /// buffer_lifetime_ordinal. Clients that need to deliver input images of
    /// different dimensions to a video encoder can either (a) allocate buffers
    /// large enough to contain the range of needed image sizes and use those to
    /// deliver all the input images, (b) keep their own sets of buffers used
    /// for different image dimensions and re-add old buffers with AddBuffer,
    /// moving to a new buffer_lifetime_ordinal each time image dimensions
    /// change, or (c) allocate new buffers each time image dimensions change.
    /// The (a) option is preferred, for clients that have the flexibiilty to
    /// store images of varying dimensions in a single set of buffers. Clients
    /// that require each buffer to have a single image size can use option (b)
    /// or (c).
    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
    /// drained (pushed through) by additional input data _or_ by this
    /// EndOfStream marker. In that sense, this message can be viewed as a drain
    /// at InputData domain level, but the drain 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 drain 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). Alternately, the client can wait
    /// for the OnOutputEndOfStream before closing the current stream.
    ///
    /// After a client sends QueueInputEndOfStream for a stream, if the client
    /// then sends for the same stream any of QueueInputPacket,
    /// QueueInputFormatDetails, QueueInputEndOfStream, the server will 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)
    }

    /// This message results in channel closure unless supports_dynamic_buffers
    /// is set to true.
    ///
    /// This participates in allocation of buffers to be used with AddBuffer
    /// later. The client can get VMO handles for these buffers by also
    /// participating in the sysmem allocation, using the client's own related
    /// sysmem token (associated with the same logical buffer collection). It's
    /// up to the client to separately set any constraints needed by the client
    /// using the client's own related sysmem token, if any.
    ///
    /// Some clients may prefer to use SetInputBufferPartialSettings and/or
    /// SetOutputBufferPartialSettings. Servers must support those messages.
    ///
    /// In handling this message, if `allow_single_buffer` is set to true, the
    /// server must not constrain the number of buffers allocated. The server
    /// must set min_buffer_count to 1, and must leave max_buffer_count un-set
    /// or set it to 0xFFFFFFFF, and must leave all min_buffer_count_* fields
    /// un-set. The sender can set min_buffer_count and max_buffer_count to the
    /// same value if the intent is to allocate exactly that many buffers. If
    /// `allow_single_buffer` is un-set or set to false, the server will
    /// indicate needed buffer counts to sysmem.
    ///
    /// The server's BufferCollection channel (created from the passed-in
    /// sysmem2_token) may see ZX_CHANNEL_PEER_CLOSED at any time, but in
    /// particular, the server shouldn't expect the BufferCollection channel to
    /// remain connected to sysmem beyond the server sending SetConstraints. For
    /// this reason, the server may not be able to call
    /// WaitForAllBuffersAllocated or similar, so the server should just send
    /// SetConstraints, Close, then close the server's BufferCollection
    /// client_end. This means the server in general shouldn't attempt to get
    /// VMO handles for these buffers while processing this message.
    ///
    /// The server should not assume that these buffers will necessarily ever be
    /// added with AddBuffer to this StreamProcessor instance or any other
    /// StreamProcessor instance (owned by the server or not). These buffers may
    /// instead be dropped, or as a less-common example, possibly added to a
    /// different codec served by a different server implementation which also
    /// participated in the same sysmem buffer collection allocation.
    ///
    /// For input buffers, AddBuffer of the allocated buffer(s) to a different
    /// StreamProcessor instance of the same codec (same per CodecFactory) is
    /// likely to work, but using the same StreamProcessor instance is
    /// recommended when feasible.
    ///
    /// In contrast, for output buffers, AddBuffer of the allocated buffer(s) to
    /// a different StreamProcessor instance of the same codec (same per
    /// CodecFactory) can't (within reason) be made work in general, especially
    /// for video decoders. Therefore, for output buffers, the same
    /// StreamProcessor instance must be used for this message and AddBuffer.
    /// While a client may currently be able to get away with using different
    /// StreamProcessor instances for this message and AddBuffer for output
    /// buffers for some codecs, this may break at any time without it being
    /// considered a server-side bug.
    ///
    /// The allocated buffers can later be added using AddBuffer (piecemeal),
    /// and can be removed (piecemeal) using RemoveBuffer.
    ///
    /// Multiple different ParticipateInBufferAllocation messages can have their
    /// buffers later added to the same StreamProcessor instance using the same
    /// buffer_lifetime_ordinal. This can be useful if the client wants to
    /// allocate buffers incrementally, or dynamically adjust the number of
    /// buffers, potentially while actively processing. See also the
    /// `buffer_lifetime_ordinal` field of this message.
    ///
    /// Server implementations may use sysmem to help verify buffer
    /// compatibility later when buffers are added with AddBuffer.
    pub fn r#participate_in_buffer_allocation(
        &self,
        mut payload: StreamProcessorParticipateInBufferAllocationRequest,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#participate_in_buffer_allocation(self, payload)
    }

    /// Add buffers previously created with the help of
    /// ParticipateInBufferAllocation.
    ///
    /// For input buffers, the client can send QueueInputFormatDetails or
    /// QueueInputEndOfStream before any AddBuffer messages. At least one input
    /// buffer must be added before a valid QueueInputPacket can be sent. Most
    /// clients will want to continue quickly adding buffers up to at least
    /// buffer_count_for_server_current to avoid the codec potentially stalling,
    /// and typically a low number of buffers beyond that to keep the pipeline
    /// running smoothly. Input buffers beyond the first input buffer can be
    /// added after the first QueueInputPacket.
    ///
    /// Even if buffer_constraints_version_ordinal is current, the server must
    /// not close the channel if the buffer isn't consistent with the current
    /// buffer_constraints_version_ordinal (per sysmem GetVmoInfo given
    /// consistent StreamProcessor constraints). Instead, the server must send a
    /// new OnOutputConstraints. This simplifies some edge cases for some
    /// clients, particularly when a client can't reliably detect whether a
    /// newly-obtained buffer was actually allocated after
    /// buffer_constraints_version_ordinal changed, or may have been cached from
    /// before.
    ///
    /// The client can add additional buffers to the same port and
    /// buffer_lifetime_ordinal at any time using this message. If the
    /// buffer_lifetime_ordinal is no longer the most recent, the message will
    /// be ignored, the handle to the buffer dropped, and any later RemoveBuffer
    /// message re. the same buffer will complete immediately.
    ///
    /// If dynamic_buffers_input_max or dynamic_buffers_output_max is exceeded
    /// by the sum of buffers added by all AddBuffer calls with the same
    /// buffer_lifetime_ordinal, the server may close the channel. Servers are
    /// required to close the channel in this case if performance degradation or
    /// un-tested behavior would result from adding too many buffers.
    ///
    /// Switching to a new buffer_lifetime_ordinal starts the process of
    /// removing buffers associated with an old buffer_lifetime_ordinal.
    /// However, until the remove is complete, those buffers can still be used
    /// by the codec as normal. See also RemoveBuffer, which can be used to
    /// detect when removal is complete, regardless of whether the RemoveBuffer
    /// started the removal (including when not using dynamic buffers).
    ///
    /// The buffer stays added until removal later completes. The buffer remains
    /// added across potentially multiple buffer re-uses. Removal can be
    /// initiated (and/or confirmed/fenced) by the client using RemoveBuffer.
    /// The codec server can unilaterally initiate buffer removal; if the server
    /// does this, it must send a new buffer_constraints_version_ordinal with
    /// action_required true. Some other client-initiated messages can also
    /// begin buffer removal, such as CloseCurrentStream with
    /// release_input_buffers and/or release_output_buffers. The buffers are
    /// also automatically removed and released if the client closes the
    /// StreamProcessor client_end or the server closes the StreamProcessor
    /// server_end.
    ///
    /// Mixing of AddBuffer and SetInputBufferPartialSettings /
    /// SetOutputBufferPartialSettings is not allowed while there are any
    /// buffers still active on the port. To successfully switch modes for a
    /// port, most clients will want to just start over with a new
    /// StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially within the same StreamProcessor.
    ///
    /// If a client might plausibly "spam" creation of many new
    /// buffer_lifetime_ordinal values without the buffers seeing any actual
    /// usage in between, the client should consider starting a Sync every few
    /// buffer_lifetime_ordinal(s) to fence cleanup of old
    /// buffer_lifetime_ordinal values, and avoid getting ahead of Sync
    /// completions by more than 16 buffer_lifetime_ordinal values. Else the
    /// channel may close from a backlog of new buffer_lifetime_ordinal(s)
    /// getting too far ahead of closing out old ones. The threshold of 16 is
    /// well below the enforcement threshold. Clients don't need to Sync if they
    /// won't be spamming new buffer_lifetime_ordinal values, or if added
    /// buffers will see at least some actual usage visible to the client before
    /// being replaced again.
    ///
    /// All buffers of the same port and buffer_lifetime_ordinal must share the
    /// same `[fuchsia.sysmem2/SingleBufferSetttings]`. The client can ensure
    /// this in various ways. One way is to use ParticipateInBufferAllocation
    /// then AddBuffer for at least the first buffer, before
    /// ParticipateInBufferAllocation for any subsequent buffers. Another way is
    /// to observe a mismatch in `SingleBufferSettings` before sending AddBuffer
    /// and bump to the next odd buffer_lifetime_ordinal value for the
    /// AddBuffer.
    pub fn r#add_buffer(
        &self,
        mut payload: StreamProcessorAddBufferRequest,
    ) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#add_buffer(self, payload)
    }

    /// When using dynamic buffers, this call removes a buffer as soon as the
    /// buffer can be removed without adversely impacting any ongoing processing
    /// or an in-flight output packet referring to the buffer.
    ///
    /// If a client wants to remove a buffer with an in-flight output packet
    /// referring to the buffer, the client must RecycleOutputPacket for that
    /// in-flight output packet before the RemoveBuffer will complete.
    ///
    /// When using SetInputBufferPartialSettings /
    /// SetOutputBufferPartialSettings, this call doesn't initiate removal of
    /// the buffer. This call will complete when the buffer is done removing due
    /// to other reasons, such as a new buffer_lifetime_ordinal starting.
    ///
    /// Until RemoveBuffer completes, the codec is still allowed to send
    /// OnOutputPacket messages referencing the buffer, and the codec may still
    /// have a VMO handle open to the buffer. After RemoveBuffer completes, the
    /// codec guarantees that no subsequent output packet will reference the
    /// buffer, and that the server holds no VMO handles to the buffer.
    ///
    /// The client may need to recycle an output packet before the RemoveBuffer
    /// call can complete. Clients should take care to avoid blocking packet
    /// recycling while the RemoveBuffer request is in progress, since this
    /// would create a potential deadlock.
    ///
    /// The server closing any VMO handles to the buffer prior to completing
    /// this call is important for the client's ability to prevent memory usage
    /// spikes.
    ///
    /// If the client has "paused" processing by not providing any more input,
    /// the client will potentially need to send CloseCurrentStream before
    /// RemoveBuffer will complete. When using dynamic buffers, setting
    /// release_input_buffers or release_output_buffers to true is not
    /// necessary; the RemoveBuffer is explicitly telling the codec to release a
    /// specific buffer. When not using dynamic buffers, the client will need to
    /// set release_input_buffers or release_output_buffers to true, since
    /// RemoveBuffer alone doesn't initiate removal when not using dynamic
    /// buffers. A current "paused" stream needs to be stopped because frames
    /// can be held as reference frames, and codecs are never reqiured to copy
    /// their output data.
    ///
    /// For any video decoder output buffers being removed while there's an
    /// active stream (being fed input or not), it's typically best for the
    /// client to assume that removal of a video decoder output buffer may take
    /// a very long duration. This is because bitstreams, especially
    /// non-standard-compliant bitstreams, but in some cases potentially even
    /// standard-compliant bitstreams, can keep a video decoder output buffer in
    /// the set of active reference frames (aka DPB) indefinitely. The server is
    /// not required to notice that a stream is not conforming to a bitstream
    /// standard in this regard.
    ///
    /// In the case of h.264 decode, a standard-complient bitstream will limit
    /// the reorder delay to no longer than the max DPB occupancy. However, a
    /// server is not required to detect or reject non-compliant streams that
    /// potentially keep a frame in the DPB for longer.
    ///
    /// For HEVC, the situation is similar to h.264 (IIUC).
    ///
    /// In the case of VP9, there is nothing in the bitstream spec that limits
    /// the reorder delay (IIUC), meaning a frame can potentially stay in VP9's
    /// set of 8 reference frames (aka DPB) indefinitely. The server is not
    /// required to detect or mitigate this.
    ///
    /// Until this call completes, the server may still be using the buffer. For
    /// output buffers, the server can still send OnOutputPacket message(s) that
    /// references this buffer, but only up until the RemoveBuffer completion
    /// message is sent by the server. The client must continue to
    /// RecycleOutputPacket for packets that reference the buffer, until
    /// RemoveBuffer completes.
    ///
    /// When using dynamic buffers, upon receiving this message, the server will
    /// stop selecting the buffer for any new usage (as in, for any usage that
    /// moves the buffer from "free" to "not free" within the server). This
    /// applies even if the server has no other buffers available for use (aka
    /// no other "free" buffers). Any existing usage of the buffer is not ended
    /// early by this call alone.
    ///
    /// When not using dynamic buffers, upon receiving this message, the server
    /// will just remember to complete this call shortly after the buffer has
    /// completed removal triggered by some other cause (removal is not
    /// triggered/caused by this call).
    ///
    /// For video decoders, when using dynamic buffers, typically the client
    /// should take care to avoid removing too many output buffers for continued
    /// decode to be possible. If this occurs, the decoder will wait until the
    /// client adds another output buffer with AddBuffer. This can be a deadlock
    /// if the client never sends that AddBuffer. Due to DPB mechanism(s) and
    /// frame reordering, sending a single AddBuffer doesn't necessarily
    /// guarantee another OnOutputPacket, since additional output buffers can be
    /// needed before the server can send OnOutputPacket.
    ///
    /// The client must not call RemoveBuffer on the same buffer more than once,
    /// whether overlapping in time or not. The server should enforce this when
    /// not enforcing would require tracking additional concurrent requests. The
    /// server is not required to enforce this when enforcing would use more
    /// server memory.
    ///
    /// The server is allowed to complete this request quickly with success for
    /// buffer_lifetime_ordinal and buffer_index combinations that were never
    /// real buffers, but must close the channel if the buffer_lifetime_ordinal
    /// hasn't been started by the client yet (no removing potential future
    /// buffers).
    ///
    /// When using dynamic buffers, a buffer_lifetime_ordinal and buffer_index
    /// combination may be re-used after completion of RemoveBuffer, but only if
    /// the buffer_lifetime_ordinal is the current buffer_lifetime_ordinal. In
    /// other words, no adding buffers under an old buffer_lifetime_ordinal.
    ///
    /// Assuming a valid historical buffer is specified, successful completion
    /// of this call means the buffer has been fully released by the server and
    /// won't be referenced in any subsequent OnOutputPacket.
    pub fn r#remove_buffer(
        &self,
        mut payload: StreamProcessorRemoveBufferRequest,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        StreamProcessorProxyInterface::r#remove_buffer(self, payload)
    }

    /// This informs the StreamProcessor that the client is prepared to handle
    /// output packets that specify a buffer with buffer_lifetime_ordinal older
    /// than the most recent buffer_lifetime_ordinal.
    ///
    /// If the client doesn't send this message, the StreamProcessor will omit
    /// any such output, even if
    /// DetailedCodecDescription.supports_dynamic_buffers is true. For relevant
    /// decoders such as VP9 decoders, not sending this message can result in
    /// output that isn't bistream spec compliant, and the output can be
    /// visually different than intended by the bitstream.
    ///
    /// Such streams are only possible with some bitstream formats (such as
    /// VP9), and are rare, but can happen and can be valid per the bitstream
    /// spec. For example, this can be specified by a VP9 bitstream using
    /// show_existing_frame to output an old-dimensions buffer after having
    /// already output a new-dimensions buffer.
    ///
    /// Most clients that send this message will also want to use RemoveBuffer
    /// to know when it becomes safe to stop tracking an old buffer.
    ///
    /// Most of the time this makes no difference as most bitstreams don't
    /// actually emit old buffers, even if the bitstream spec would allow it.
    /// Old output buffers are especially rare for RTC streams which typically
    /// don't have any frame reordering in the first place.
    ///
    /// In most video streaming scenarios that use dimension switching as part
    /// of their bitrate control strategy (among those that I've observed), at
    /// the StreamProcessor layer the new dimensions are part of a new stream
    /// instead of being spliced together as a continuation of the old stream.
    /// That said, using a continuation of the old stream is also a completely
    /// valid way to implement dimension switching. When a stream switch occurs
    /// as part of dimension switching, the decoder state is not retained and
    /// there won't be any old buffer(s) emitted after new buffer(s), since the
    /// new stream doesn't know anything about old buffers filled by the old
    /// stream.
    ///
    /// Clients which haven't tested their ability to handle old output buffers
    /// should not send this message. Clients decoding bitstreams like VP9 for
    /// decoder compliance testing purposes should send this message (and use a
    /// VP9 decoder with DetailedCodecDescrption.supports_dynamic_buffers true).
    /// Clients which are required to support old output frames and/or fully
    /// comply with a relevant bitstream spec should/must send this message, and
    /// should test using a test stream that outputs packets referencing an old
    /// output buffer.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to the client establishing the first output
    /// buffer_lifetime_ordinal. This requirement avoids ambiguity re. free/busy
    /// status of packets of old buffer_lifetime_ordinal(s), as the server can
    /// auto-recycle packets with old buffer_lifetime_ordinal on behalf of the
    /// client when this message was not sent by the client.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    pub fn r#enable_old_output_buffers(&self) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#enable_old_output_buffers(self)
    }

    /// This informs the StreamProcessor that the client is prepared to handle
    /// output packets that specify the same buffer as another packet that's
    /// also concurrently in flight to the client (not yet recycled).
    ///
    /// Most bitstream formats don't do this. In formats that can do this such
    /// as VP9, most actual bitstreams don't do this.
    ///
    /// As an example, in VP9, a stream can cause the same output buffer to be
    /// used by another emitted output packet/frame by using show_existing_frame
    /// on the same VP9 reference/held frame slot more than once without
    /// decoding a new frame into that slot in between.
    ///
    /// Clients that need to achieve full bitstream spec compliance for such a
    /// bitstream format must send this message.
    ///
    /// If this message is not in effect, the server will omit any such output,
    /// which can result in output that is not compliant to the relevant
    /// bitstream spec, and which can be visually different than the stream
    /// intended.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to the client establishing the first output
    /// buffer_lifetime_ordinal.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    pub fn r#enable_same_output_buffer_concurrently_in_flight(&self) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#enable_same_output_buffer_concurrently_in_flight(self)
    }

    /// For video decoders, this forces the output buffers to be reallocated if
    /// the image size needs to change. This is wasteful as it forces extra
    /// buffer reallocations given typical video bitrate control strategies
    /// (applicable to both streaming and RTC) involving shifting the image
    /// dimensions up and down repeatedly as a logical video/stream plays,
    /// sometimes even if network conditions remain fairly stable. This extra
    /// buffer reallocation cost is incurred vs. baseline whether the dimension
    /// switching is achieved within a single StreamProcessor stream or by using
    /// a new StreamProcessor stream for new dimensions.
    ///
    /// A client should not send this message unless the client really must
    /// force the output buffers to be reallocated every time the output image
    /// size changes.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to any SetInputBufferPartialSettings,
    /// SetOutputBufferPartialSettings, ParticipateInBufferAllocation, or
    /// AddBuffer.
    ///
    /// This message is only permitted if this StreamProcessor is a video
    /// decoder.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    pub fn r#enable_force_output_buffers_fixed_image_size(&self) -> Result<(), fidl::Error> {
        StreamProcessorProxyInterface::r#enable_force_output_buffers_fixed_image_size(self)
    }
}

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

    fn r#participate_in_buffer_allocation(
        &self,
        mut payload: StreamProcessorParticipateInBufferAllocationRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorParticipateInBufferAllocationRequest>(
            &mut payload,
            0x122be3b0096183cb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#add_buffer(
        &self,
        mut payload: StreamProcessorAddBufferRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<StreamProcessorAddBufferRequest>(
            &mut payload,
            0x6eca773e923e0ada,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type RemoveBufferResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#remove_buffer(
        &self,
        mut payload: StreamProcessorRemoveBufferRequest,
    ) -> Self::RemoveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x40b967ffa6b2da43,
            >(_buf?)?
            .into_result_fdomain::<StreamProcessorMarker>("remove_buffer")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<StreamProcessorRemoveBufferRequest, ()>(
            &mut payload,
            0x40b967ffa6b2da43,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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,
    },
    OnOutputTimestampHasNoOutput {
        payload: StreamProcessorOnOutputTimestampHasNoOutputRequest,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

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
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_output_timestamp_has_no_output(
        self,
    ) -> Option<StreamProcessorOnOutputTimestampHasNoOutputRequest> {
        if let StreamProcessorEvent::OnOutputTimestampHasNoOutput { payload } = self {
            Some((payload))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`StreamProcessorEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect 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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamProcessorOnFreeInputPacketRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnFreeInputPacket {
                    free_input_packet: out.free_input_packet,
                }))
            }
            0x7436457799a25cd4 => {
                let mut out = fidl::new_empty!(
                    StreamProcessorOnOutputTimestampHasNoOutputRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamProcessorOnOutputTimestampHasNoOutputRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((StreamProcessorEvent::OnOutputTimestampHasNoOutput { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(StreamProcessorEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <StreamProcessorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for StreamProcessorRequestStream {
    type Protocol = StreamProcessorMarker;
    type ControlHandle = StreamProcessorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x3940929617dbf02b => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                    })
                }
                0x122be3b0096183cb => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(StreamProcessorParticipateInBufferAllocationRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamProcessorParticipateInBufferAllocationRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::ParticipateInBufferAllocation {payload: req,
                        control_handle,
                    })
                }
                0x6eca773e923e0ada => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(StreamProcessorAddBufferRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamProcessorAddBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::AddBuffer {payload: req,
                        control_handle,
                    })
                }
                0x40b967ffa6b2da43 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(StreamProcessorRemoveBufferRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StreamProcessorRemoveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::RemoveBuffer {payload: req,
                        responder: StreamProcessorRemoveBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3aedefeedf3898b0 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::EnableOldOutputBuffers {
                        control_handle,
                    })
                }
                0x244e9f43b29709e7 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::EnableSameOutputBufferConcurrentlyInFlight {
                        control_handle,
                    })
                }
                0x3994b040f91dc1e9 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StreamProcessorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StreamProcessorRequest::EnableForceOutputBuffersFixedImageSize {
                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(StreamProcessorRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: StreamProcessorControlHandle { 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(StreamProcessorRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: StreamProcessorControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <StreamProcessorMarker as fdomain_client::fidl::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()
///   * or AddBuffer, if StreamProcessor reported support for dynamic buffers
///     via CodecFactory - in this case, QueueInputFormatDetails and
///     QueueInputEndOfStream do not require a prior AddBuffer, but
///     QueueInputPacket still does.
/// 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 },
    /// When the client is not using dynamic buffers, 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.
    ///
    /// Mixing of AddBuffer and SetInputBufferPartialSettings is not allowed
    /// while there are any buffers still active on the port. To successfully
    /// switch modes for a port, most clients will want to just start over with
    /// a new StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially within the same StreamProcessor.
    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.
    ///
    /// Mixing of AddBuffer and SetOutputBufferPartialSettings is not allowed
    /// while there are any buffers still active on the port. To successfully
    /// switch modes for a port, most clients will want to just start over with
    /// a new StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially not within the same StreamProcessor instance.
    ///
    /// 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().
    ///
    /// This message isn't permitted after AddBuffer. When using dynamic buffers
    /// the server can send OnOutputConstraints, OnOutputFormat, OnOutputPacket,
    /// or OnOutputEndOfStream at any time after the first QueueInputPacket. In
    /// the case of OnOutputPacket there must also be at least one output buffer
    /// that's been added but not yet fully removed (RemoveBuffer not yet
    /// complete).
    ///
    /// 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; a client isn't required to send this ever.
    ///
    /// Terminology note: In the name of this message, "flush" means flush
    /// through, sometimes called "drain". This messge does not discard. To
    /// discard, just QueueInputPacket with a new stream_lifetime_ordinal
    /// without first waiting for OnOutputEndOfStream of the old stream and
    /// without sending FlushEndOfStreamAndCloseStream.
    ///
    /// There is currently no way to cancel the flush effect of this message
    /// short of the client closing the StreamProcessor channel.
    ///
    /// 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 (drain, 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 (and unregister) 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, using this message.
    ///
    /// It's not permitted to recycle an output packet that's already free with
    /// the stream processor server.
    ///
    /// If a client is using EnableOldOutputBuffers, the client must recycle all
    /// packets when done with them, even those of old buffer_lifetime_ordinal.
    /// This is also permitted behavior for all clients.
    ///
    /// If a client is not using EnableOldOutputBuffers, the client may
    /// optionally omit this message for packets with an old
    /// buffer_lifetime_ordinal. In other words, packets from before an explicit
    /// or implicit output buffer de-configuration don't need to be recycled if
    /// the client isn't using and won't be using EnableOldOutputBuffers.
    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.
    ///
    /// When using dynamic buffers the server can send OnOutputConstraints,
    /// OnOutputFormat, OnOutputPacket, or OnOutputEndOfStream at any time after
    /// the first QueueInputPacket. In the case of OnOutputPacket there must
    /// also be at least one output buffer that's been added but not yet fully
    /// removed (RemoveBuffer not yet complete).
    ///
    /// 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.
    ///
    /// The server will close the channel if this packet refers to an old
    /// buffer_lifetime_ordinal. Clients that need to deliver input images of
    /// different dimensions to a video encoder can either (a) allocate buffers
    /// large enough to contain the range of needed image sizes and use those to
    /// deliver all the input images, (b) keep their own sets of buffers used
    /// for different image dimensions and re-add old buffers with AddBuffer,
    /// moving to a new buffer_lifetime_ordinal each time image dimensions
    /// change, or (c) allocate new buffers each time image dimensions change.
    /// The (a) option is preferred, for clients that have the flexibiilty to
    /// store images of varying dimensions in a single set of buffers. Clients
    /// that require each buffer to have a single image size can use option (b)
    /// or (c).
    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
    /// drained (pushed through) by additional input data _or_ by this
    /// EndOfStream marker. In that sense, this message can be viewed as a drain
    /// at InputData domain level, but the drain 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 drain 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). Alternately, the client can wait
    /// for the OnOutputEndOfStream before closing the current stream.
    ///
    /// After a client sends QueueInputEndOfStream for a stream, if the client
    /// then sends for the same stream any of QueueInputPacket,
    /// QueueInputFormatDetails, QueueInputEndOfStream, the server will close
    /// the StreamProcessor channel.
    QueueInputEndOfStream {
        stream_lifetime_ordinal: u64,
        control_handle: StreamProcessorControlHandle,
    },
    /// This message results in channel closure unless supports_dynamic_buffers
    /// is set to true.
    ///
    /// This participates in allocation of buffers to be used with AddBuffer
    /// later. The client can get VMO handles for these buffers by also
    /// participating in the sysmem allocation, using the client's own related
    /// sysmem token (associated with the same logical buffer collection). It's
    /// up to the client to separately set any constraints needed by the client
    /// using the client's own related sysmem token, if any.
    ///
    /// Some clients may prefer to use SetInputBufferPartialSettings and/or
    /// SetOutputBufferPartialSettings. Servers must support those messages.
    ///
    /// In handling this message, if `allow_single_buffer` is set to true, the
    /// server must not constrain the number of buffers allocated. The server
    /// must set min_buffer_count to 1, and must leave max_buffer_count un-set
    /// or set it to 0xFFFFFFFF, and must leave all min_buffer_count_* fields
    /// un-set. The sender can set min_buffer_count and max_buffer_count to the
    /// same value if the intent is to allocate exactly that many buffers. If
    /// `allow_single_buffer` is un-set or set to false, the server will
    /// indicate needed buffer counts to sysmem.
    ///
    /// The server's BufferCollection channel (created from the passed-in
    /// sysmem2_token) may see ZX_CHANNEL_PEER_CLOSED at any time, but in
    /// particular, the server shouldn't expect the BufferCollection channel to
    /// remain connected to sysmem beyond the server sending SetConstraints. For
    /// this reason, the server may not be able to call
    /// WaitForAllBuffersAllocated or similar, so the server should just send
    /// SetConstraints, Close, then close the server's BufferCollection
    /// client_end. This means the server in general shouldn't attempt to get
    /// VMO handles for these buffers while processing this message.
    ///
    /// The server should not assume that these buffers will necessarily ever be
    /// added with AddBuffer to this StreamProcessor instance or any other
    /// StreamProcessor instance (owned by the server or not). These buffers may
    /// instead be dropped, or as a less-common example, possibly added to a
    /// different codec served by a different server implementation which also
    /// participated in the same sysmem buffer collection allocation.
    ///
    /// For input buffers, AddBuffer of the allocated buffer(s) to a different
    /// StreamProcessor instance of the same codec (same per CodecFactory) is
    /// likely to work, but using the same StreamProcessor instance is
    /// recommended when feasible.
    ///
    /// In contrast, for output buffers, AddBuffer of the allocated buffer(s) to
    /// a different StreamProcessor instance of the same codec (same per
    /// CodecFactory) can't (within reason) be made work in general, especially
    /// for video decoders. Therefore, for output buffers, the same
    /// StreamProcessor instance must be used for this message and AddBuffer.
    /// While a client may currently be able to get away with using different
    /// StreamProcessor instances for this message and AddBuffer for output
    /// buffers for some codecs, this may break at any time without it being
    /// considered a server-side bug.
    ///
    /// The allocated buffers can later be added using AddBuffer (piecemeal),
    /// and can be removed (piecemeal) using RemoveBuffer.
    ///
    /// Multiple different ParticipateInBufferAllocation messages can have their
    /// buffers later added to the same StreamProcessor instance using the same
    /// buffer_lifetime_ordinal. This can be useful if the client wants to
    /// allocate buffers incrementally, or dynamically adjust the number of
    /// buffers, potentially while actively processing. See also the
    /// `buffer_lifetime_ordinal` field of this message.
    ///
    /// Server implementations may use sysmem to help verify buffer
    /// compatibility later when buffers are added with AddBuffer.
    ParticipateInBufferAllocation {
        payload: StreamProcessorParticipateInBufferAllocationRequest,
        control_handle: StreamProcessorControlHandle,
    },
    /// Add buffers previously created with the help of
    /// ParticipateInBufferAllocation.
    ///
    /// For input buffers, the client can send QueueInputFormatDetails or
    /// QueueInputEndOfStream before any AddBuffer messages. At least one input
    /// buffer must be added before a valid QueueInputPacket can be sent. Most
    /// clients will want to continue quickly adding buffers up to at least
    /// buffer_count_for_server_current to avoid the codec potentially stalling,
    /// and typically a low number of buffers beyond that to keep the pipeline
    /// running smoothly. Input buffers beyond the first input buffer can be
    /// added after the first QueueInputPacket.
    ///
    /// Even if buffer_constraints_version_ordinal is current, the server must
    /// not close the channel if the buffer isn't consistent with the current
    /// buffer_constraints_version_ordinal (per sysmem GetVmoInfo given
    /// consistent StreamProcessor constraints). Instead, the server must send a
    /// new OnOutputConstraints. This simplifies some edge cases for some
    /// clients, particularly when a client can't reliably detect whether a
    /// newly-obtained buffer was actually allocated after
    /// buffer_constraints_version_ordinal changed, or may have been cached from
    /// before.
    ///
    /// The client can add additional buffers to the same port and
    /// buffer_lifetime_ordinal at any time using this message. If the
    /// buffer_lifetime_ordinal is no longer the most recent, the message will
    /// be ignored, the handle to the buffer dropped, and any later RemoveBuffer
    /// message re. the same buffer will complete immediately.
    ///
    /// If dynamic_buffers_input_max or dynamic_buffers_output_max is exceeded
    /// by the sum of buffers added by all AddBuffer calls with the same
    /// buffer_lifetime_ordinal, the server may close the channel. Servers are
    /// required to close the channel in this case if performance degradation or
    /// un-tested behavior would result from adding too many buffers.
    ///
    /// Switching to a new buffer_lifetime_ordinal starts the process of
    /// removing buffers associated with an old buffer_lifetime_ordinal.
    /// However, until the remove is complete, those buffers can still be used
    /// by the codec as normal. See also RemoveBuffer, which can be used to
    /// detect when removal is complete, regardless of whether the RemoveBuffer
    /// started the removal (including when not using dynamic buffers).
    ///
    /// The buffer stays added until removal later completes. The buffer remains
    /// added across potentially multiple buffer re-uses. Removal can be
    /// initiated (and/or confirmed/fenced) by the client using RemoveBuffer.
    /// The codec server can unilaterally initiate buffer removal; if the server
    /// does this, it must send a new buffer_constraints_version_ordinal with
    /// action_required true. Some other client-initiated messages can also
    /// begin buffer removal, such as CloseCurrentStream with
    /// release_input_buffers and/or release_output_buffers. The buffers are
    /// also automatically removed and released if the client closes the
    /// StreamProcessor client_end or the server closes the StreamProcessor
    /// server_end.
    ///
    /// Mixing of AddBuffer and SetInputBufferPartialSettings /
    /// SetOutputBufferPartialSettings is not allowed while there are any
    /// buffers still active on the port. To successfully switch modes for a
    /// port, most clients will want to just start over with a new
    /// StreamProcessor instance. This can also be done reliably by first
    /// ensuring that every added buffer under the port up to "now" (including
    /// those with older buffer_lifetime_ordinal) has completed a RemoveBuffer
    /// request. Only then is it known ok to switch modes for that port under
    /// the same StreamProcessor. Most clients will just use one way or the
    /// other to add buffers and never need to switch to the other way,
    /// especially within the same StreamProcessor.
    ///
    /// If a client might plausibly "spam" creation of many new
    /// buffer_lifetime_ordinal values without the buffers seeing any actual
    /// usage in between, the client should consider starting a Sync every few
    /// buffer_lifetime_ordinal(s) to fence cleanup of old
    /// buffer_lifetime_ordinal values, and avoid getting ahead of Sync
    /// completions by more than 16 buffer_lifetime_ordinal values. Else the
    /// channel may close from a backlog of new buffer_lifetime_ordinal(s)
    /// getting too far ahead of closing out old ones. The threshold of 16 is
    /// well below the enforcement threshold. Clients don't need to Sync if they
    /// won't be spamming new buffer_lifetime_ordinal values, or if added
    /// buffers will see at least some actual usage visible to the client before
    /// being replaced again.
    ///
    /// All buffers of the same port and buffer_lifetime_ordinal must share the
    /// same `[fuchsia.sysmem2/SingleBufferSetttings]`. The client can ensure
    /// this in various ways. One way is to use ParticipateInBufferAllocation
    /// then AddBuffer for at least the first buffer, before
    /// ParticipateInBufferAllocation for any subsequent buffers. Another way is
    /// to observe a mismatch in `SingleBufferSettings` before sending AddBuffer
    /// and bump to the next odd buffer_lifetime_ordinal value for the
    /// AddBuffer.
    AddBuffer {
        payload: StreamProcessorAddBufferRequest,
        control_handle: StreamProcessorControlHandle,
    },
    /// When using dynamic buffers, this call removes a buffer as soon as the
    /// buffer can be removed without adversely impacting any ongoing processing
    /// or an in-flight output packet referring to the buffer.
    ///
    /// If a client wants to remove a buffer with an in-flight output packet
    /// referring to the buffer, the client must RecycleOutputPacket for that
    /// in-flight output packet before the RemoveBuffer will complete.
    ///
    /// When using SetInputBufferPartialSettings /
    /// SetOutputBufferPartialSettings, this call doesn't initiate removal of
    /// the buffer. This call will complete when the buffer is done removing due
    /// to other reasons, such as a new buffer_lifetime_ordinal starting.
    ///
    /// Until RemoveBuffer completes, the codec is still allowed to send
    /// OnOutputPacket messages referencing the buffer, and the codec may still
    /// have a VMO handle open to the buffer. After RemoveBuffer completes, the
    /// codec guarantees that no subsequent output packet will reference the
    /// buffer, and that the server holds no VMO handles to the buffer.
    ///
    /// The client may need to recycle an output packet before the RemoveBuffer
    /// call can complete. Clients should take care to avoid blocking packet
    /// recycling while the RemoveBuffer request is in progress, since this
    /// would create a potential deadlock.
    ///
    /// The server closing any VMO handles to the buffer prior to completing
    /// this call is important for the client's ability to prevent memory usage
    /// spikes.
    ///
    /// If the client has "paused" processing by not providing any more input,
    /// the client will potentially need to send CloseCurrentStream before
    /// RemoveBuffer will complete. When using dynamic buffers, setting
    /// release_input_buffers or release_output_buffers to true is not
    /// necessary; the RemoveBuffer is explicitly telling the codec to release a
    /// specific buffer. When not using dynamic buffers, the client will need to
    /// set release_input_buffers or release_output_buffers to true, since
    /// RemoveBuffer alone doesn't initiate removal when not using dynamic
    /// buffers. A current "paused" stream needs to be stopped because frames
    /// can be held as reference frames, and codecs are never reqiured to copy
    /// their output data.
    ///
    /// For any video decoder output buffers being removed while there's an
    /// active stream (being fed input or not), it's typically best for the
    /// client to assume that removal of a video decoder output buffer may take
    /// a very long duration. This is because bitstreams, especially
    /// non-standard-compliant bitstreams, but in some cases potentially even
    /// standard-compliant bitstreams, can keep a video decoder output buffer in
    /// the set of active reference frames (aka DPB) indefinitely. The server is
    /// not required to notice that a stream is not conforming to a bitstream
    /// standard in this regard.
    ///
    /// In the case of h.264 decode, a standard-complient bitstream will limit
    /// the reorder delay to no longer than the max DPB occupancy. However, a
    /// server is not required to detect or reject non-compliant streams that
    /// potentially keep a frame in the DPB for longer.
    ///
    /// For HEVC, the situation is similar to h.264 (IIUC).
    ///
    /// In the case of VP9, there is nothing in the bitstream spec that limits
    /// the reorder delay (IIUC), meaning a frame can potentially stay in VP9's
    /// set of 8 reference frames (aka DPB) indefinitely. The server is not
    /// required to detect or mitigate this.
    ///
    /// Until this call completes, the server may still be using the buffer. For
    /// output buffers, the server can still send OnOutputPacket message(s) that
    /// references this buffer, but only up until the RemoveBuffer completion
    /// message is sent by the server. The client must continue to
    /// RecycleOutputPacket for packets that reference the buffer, until
    /// RemoveBuffer completes.
    ///
    /// When using dynamic buffers, upon receiving this message, the server will
    /// stop selecting the buffer for any new usage (as in, for any usage that
    /// moves the buffer from "free" to "not free" within the server). This
    /// applies even if the server has no other buffers available for use (aka
    /// no other "free" buffers). Any existing usage of the buffer is not ended
    /// early by this call alone.
    ///
    /// When not using dynamic buffers, upon receiving this message, the server
    /// will just remember to complete this call shortly after the buffer has
    /// completed removal triggered by some other cause (removal is not
    /// triggered/caused by this call).
    ///
    /// For video decoders, when using dynamic buffers, typically the client
    /// should take care to avoid removing too many output buffers for continued
    /// decode to be possible. If this occurs, the decoder will wait until the
    /// client adds another output buffer with AddBuffer. This can be a deadlock
    /// if the client never sends that AddBuffer. Due to DPB mechanism(s) and
    /// frame reordering, sending a single AddBuffer doesn't necessarily
    /// guarantee another OnOutputPacket, since additional output buffers can be
    /// needed before the server can send OnOutputPacket.
    ///
    /// The client must not call RemoveBuffer on the same buffer more than once,
    /// whether overlapping in time or not. The server should enforce this when
    /// not enforcing would require tracking additional concurrent requests. The
    /// server is not required to enforce this when enforcing would use more
    /// server memory.
    ///
    /// The server is allowed to complete this request quickly with success for
    /// buffer_lifetime_ordinal and buffer_index combinations that were never
    /// real buffers, but must close the channel if the buffer_lifetime_ordinal
    /// hasn't been started by the client yet (no removing potential future
    /// buffers).
    ///
    /// When using dynamic buffers, a buffer_lifetime_ordinal and buffer_index
    /// combination may be re-used after completion of RemoveBuffer, but only if
    /// the buffer_lifetime_ordinal is the current buffer_lifetime_ordinal. In
    /// other words, no adding buffers under an old buffer_lifetime_ordinal.
    ///
    /// Assuming a valid historical buffer is specified, successful completion
    /// of this call means the buffer has been fully released by the server and
    /// won't be referenced in any subsequent OnOutputPacket.
    RemoveBuffer {
        payload: StreamProcessorRemoveBufferRequest,
        responder: StreamProcessorRemoveBufferResponder,
    },
    /// This informs the StreamProcessor that the client is prepared to handle
    /// output packets that specify a buffer with buffer_lifetime_ordinal older
    /// than the most recent buffer_lifetime_ordinal.
    ///
    /// If the client doesn't send this message, the StreamProcessor will omit
    /// any such output, even if
    /// DetailedCodecDescription.supports_dynamic_buffers is true. For relevant
    /// decoders such as VP9 decoders, not sending this message can result in
    /// output that isn't bistream spec compliant, and the output can be
    /// visually different than intended by the bitstream.
    ///
    /// Such streams are only possible with some bitstream formats (such as
    /// VP9), and are rare, but can happen and can be valid per the bitstream
    /// spec. For example, this can be specified by a VP9 bitstream using
    /// show_existing_frame to output an old-dimensions buffer after having
    /// already output a new-dimensions buffer.
    ///
    /// Most clients that send this message will also want to use RemoveBuffer
    /// to know when it becomes safe to stop tracking an old buffer.
    ///
    /// Most of the time this makes no difference as most bitstreams don't
    /// actually emit old buffers, even if the bitstream spec would allow it.
    /// Old output buffers are especially rare for RTC streams which typically
    /// don't have any frame reordering in the first place.
    ///
    /// In most video streaming scenarios that use dimension switching as part
    /// of their bitrate control strategy (among those that I've observed), at
    /// the StreamProcessor layer the new dimensions are part of a new stream
    /// instead of being spliced together as a continuation of the old stream.
    /// That said, using a continuation of the old stream is also a completely
    /// valid way to implement dimension switching. When a stream switch occurs
    /// as part of dimension switching, the decoder state is not retained and
    /// there won't be any old buffer(s) emitted after new buffer(s), since the
    /// new stream doesn't know anything about old buffers filled by the old
    /// stream.
    ///
    /// Clients which haven't tested their ability to handle old output buffers
    /// should not send this message. Clients decoding bitstreams like VP9 for
    /// decoder compliance testing purposes should send this message (and use a
    /// VP9 decoder with DetailedCodecDescrption.supports_dynamic_buffers true).
    /// Clients which are required to support old output frames and/or fully
    /// comply with a relevant bitstream spec should/must send this message, and
    /// should test using a test stream that outputs packets referencing an old
    /// output buffer.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to the client establishing the first output
    /// buffer_lifetime_ordinal. This requirement avoids ambiguity re. free/busy
    /// status of packets of old buffer_lifetime_ordinal(s), as the server can
    /// auto-recycle packets with old buffer_lifetime_ordinal on behalf of the
    /// client when this message was not sent by the client.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    EnableOldOutputBuffers { control_handle: StreamProcessorControlHandle },
    /// This informs the StreamProcessor that the client is prepared to handle
    /// output packets that specify the same buffer as another packet that's
    /// also concurrently in flight to the client (not yet recycled).
    ///
    /// Most bitstream formats don't do this. In formats that can do this such
    /// as VP9, most actual bitstreams don't do this.
    ///
    /// As an example, in VP9, a stream can cause the same output buffer to be
    /// used by another emitted output packet/frame by using show_existing_frame
    /// on the same VP9 reference/held frame slot more than once without
    /// decoding a new frame into that slot in between.
    ///
    /// Clients that need to achieve full bitstream spec compliance for such a
    /// bitstream format must send this message.
    ///
    /// If this message is not in effect, the server will omit any such output,
    /// which can result in output that is not compliant to the relevant
    /// bitstream spec, and which can be visually different than the stream
    /// intended.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to the client establishing the first output
    /// buffer_lifetime_ordinal.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    EnableSameOutputBufferConcurrentlyInFlight { control_handle: StreamProcessorControlHandle },
    /// For video decoders, this forces the output buffers to be reallocated if
    /// the image size needs to change. This is wasteful as it forces extra
    /// buffer reallocations given typical video bitrate control strategies
    /// (applicable to both streaming and RTC) involving shifting the image
    /// dimensions up and down repeatedly as a logical video/stream plays,
    /// sometimes even if network conditions remain fairly stable. This extra
    /// buffer reallocation cost is incurred vs. baseline whether the dimension
    /// switching is achieved within a single StreamProcessor stream or by using
    /// a new StreamProcessor stream for new dimensions.
    ///
    /// A client should not send this message unless the client really must
    /// force the output buffers to be reallocated every time the output image
    /// size changes.
    ///
    /// Sending this message more than once closes the channel. If sent, this
    /// message must be sent prior to any SetInputBufferPartialSettings,
    /// SetOutputBufferPartialSettings, ParticipateInBufferAllocation, or
    /// AddBuffer.
    ///
    /// This message is only permitted if this StreamProcessor is a video
    /// decoder.
    ///
    /// This message is only permitted when
    /// `[fuchsia.mediacodec/CodecFactory.DetailedCodecDescription.supports_dynamic_buffers]`
    /// is true.
    EnableForceOutputBuffersFixedImageSize { control_handle: StreamProcessorControlHandle },
    /// 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: StreamProcessorControlHandle,
        method_type: fidl::MethodType,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_participate_in_buffer_allocation(
        self,
    ) -> Option<(StreamProcessorParticipateInBufferAllocationRequest, StreamProcessorControlHandle)>
    {
        if let StreamProcessorRequest::ParticipateInBufferAllocation { payload, control_handle } =
            self
        {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_buffer(
        self,
    ) -> Option<(StreamProcessorAddBufferRequest, StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::AddBuffer { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_buffer(
        self,
    ) -> Option<(StreamProcessorRemoveBufferRequest, StreamProcessorRemoveBufferResponder)> {
        if let StreamProcessorRequest::RemoveBuffer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_old_output_buffers(self) -> Option<(StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::EnableOldOutputBuffers { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_same_output_buffer_concurrently_in_flight(
        self,
    ) -> Option<(StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::EnableSameOutputBufferConcurrentlyInFlight {
            control_handle,
        } = self
        {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_force_output_buffers_fixed_image_size(
        self,
    ) -> Option<(StreamProcessorControlHandle)> {
        if let StreamProcessorRequest::EnableForceOutputBuffersFixedImageSize { control_handle } =
            self
        {
            Some((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",
            StreamProcessorRequest::ParticipateInBufferAllocation { .. } => {
                "participate_in_buffer_allocation"
            }
            StreamProcessorRequest::AddBuffer { .. } => "add_buffer",
            StreamProcessorRequest::RemoveBuffer { .. } => "remove_buffer",
            StreamProcessorRequest::EnableOldOutputBuffers { .. } => "enable_old_output_buffers",
            StreamProcessorRequest::EnableSameOutputBufferConcurrentlyInFlight { .. } => {
                "enable_same_output_buffer_concurrently_in_flight"
            }
            StreamProcessorRequest::EnableForceOutputBuffersFixedImageSize { .. } => {
                "enable_force_output_buffers_fixed_image_size"
            }
            StreamProcessorRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            StreamProcessorRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

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

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

impl 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(),
        )
    }

    pub fn send_on_output_timestamp_has_no_output(
        &self,
        mut payload: &StreamProcessorOnOutputTimestampHasNoOutputRequest,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<StreamProcessorOnOutputTimestampHasNoOutputRequest>(
            payload,
            0,
            0x7436457799a25cd4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 fdomain_client::fidl::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(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamProcessorRemoveBufferResponder {
    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 StreamProcessorRemoveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for StreamSinkMarker {
    type Proxy = StreamSinkProxy;
    type RequestStream = StreamSinkRequestStream;

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

impl fdomain_client::fidl::Proxy for StreamSinkProxy {
    type Protocol = StreamSinkMarker;

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#send_packet(&self, mut packet: &StreamPacket) -> Self::SendPacketResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for StreamSinkRequestStream {
    type Protocol = StreamSinkMarker;
    type ControlHandle = StreamSinkControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x67cddd607442775f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSinkSendPacketRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = StreamSinkControlHandle { inner: this.inner.clone() };
                        Ok(StreamSinkRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSinkMarker as fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for StreamSourceMarker {
    type Proxy = StreamSourceProxy;
    type RequestStream = StreamSourceRequestStream;

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

impl fdomain_client::fidl::Proxy for StreamSourceProxy {
    type Protocol = StreamSourceMarker;

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<(), fdomain_client::fidl::FDomainResourceDialect> {
        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<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#discard_all_packets(&self) -> Self::DiscardAllPacketsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for StreamSourceRequestStream {
    type Protocol = StreamSourceMarker;
    type ControlHandle = StreamSourceControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7a7b57f0f7d9e4bb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSourceReleasePacketRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSourceControlHandle { inner: this.inner.clone() };
                        Ok(StreamSourceRequest::DiscardAllPacketsNoReply { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSourceMarker as fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for Usage2AudioConsumerFactoryMarker {
    type Proxy = Usage2AudioConsumerFactoryProxy;
    type RequestStream = Usage2AudioConsumerFactoryRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.Usage2AudioConsumerFactory";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for Usage2AudioConsumerFactoryMarker {}

pub trait Usage2AudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        usage: AudioRenderUsage2,
        audio_consumer_request: fdomain_client::fidl::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for Usage2AudioConsumerFactoryProxy {
    type Protocol = Usage2AudioConsumerFactoryMarker;

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for Usage2AudioConsumerFactoryRequestStream {
    type Protocol = Usage2AudioConsumerFactoryMarker;
    type ControlHandle = Usage2AudioConsumerFactoryControlHandle;

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

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

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

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

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

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

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

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

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

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

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

impl Usage2AudioConsumerFactoryControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for UsageAudioConsumerFactoryMarker {
    type Proxy = UsageAudioConsumerFactoryProxy;
    type RequestStream = UsageAudioConsumerFactoryRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageAudioConsumerFactory";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for UsageAudioConsumerFactoryMarker {}

pub trait UsageAudioConsumerFactoryProxyInterface: Send + Sync {
    fn r#create_audio_consumer(
        &self,
        usage: AudioRenderUsage,
        audio_consumer_request: fdomain_client::fidl::ServerEnd<AudioConsumerMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for UsageAudioConsumerFactoryProxy {
    type Protocol = UsageAudioConsumerFactoryMarker;

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

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

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

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

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

    pub fn r#create_audio_consumer(
        &self,
        mut usage: AudioRenderUsage,
        mut audio_consumer_request: fdomain_client::fidl::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: fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageAudioConsumerFactoryRequestStream {
    type Protocol = UsageAudioConsumerFactoryMarker;
    type ControlHandle = UsageAudioConsumerFactoryControlHandle;

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

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

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

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

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

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

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

/// Interface for creating audio consumers for local rendering.
#[derive(Debug)]
pub enum UsageAudioConsumerFactoryRequest {
    CreateAudioConsumer {
        usage: AudioRenderUsage,
        audio_consumer_request: fdomain_client::fidl::ServerEnd<AudioConsumerMarker>,
        control_handle: UsageAudioConsumerFactoryControlHandle,
    },
}

impl UsageAudioConsumerFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_audio_consumer(
        self,
    ) -> Option<(
        AudioRenderUsage,
        fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl UsageAudioConsumerFactoryControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for UsageGainListenerMarker {
    type Proxy = UsageGainListenerProxy;
    type RequestStream = UsageGainListenerRequestStream;

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

impl fdomain_client::fidl::Proxy for UsageGainListenerProxy {
    type Protocol = UsageGainListenerMarker;

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

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

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

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

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

impl UsageGainListenerProxyInterface for UsageGainListenerProxy {
    type OnGainMuteChangedResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#on_gain_mute_changed(
        &self,
        mut muted: bool,
        mut gain_dbfs: f32,
    ) -> Self::OnGainMuteChangedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageGainListenerRequestStream {
    type Protocol = UsageGainListenerMarker;
    type ControlHandle = UsageGainListenerControlHandle;

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for UsageGainReporterMarker {
    type Proxy = UsageGainReporterProxy;
    type RequestStream = UsageGainReporterRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageGainReporter";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for UsageGainReporterMarker {}

pub trait UsageGainReporterProxyInterface: Send + Sync {
    fn r#register_listener(
        &self,
        device_unique_id: &str,
        usage: &Usage,
        usage_gain_listener: fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#register_listener2(
        &self,
        device_unique_id: &str,
        usage: &Usage2,
        usage_gain_listener: fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for UsageGainReporterProxy {
    type Protocol = UsageGainReporterMarker;

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageGainReporterRequestStream {
    type Protocol = UsageGainReporterMarker;
    type ControlHandle = UsageGainReporterControlHandle;

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

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

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

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

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

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

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

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

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

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

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

impl UsageGainReporterControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for UsageReporterMarker {
    type Proxy = UsageReporterProxy;
    type RequestStream = UsageReporterRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.media.UsageReporter";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for UsageReporterMarker {}

pub trait UsageReporterProxyInterface: Send + Sync {
    fn r#watch(
        &self,
        usage: &Usage,
        usage_watcher: fdomain_client::fidl::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#watch2(
        &self,
        usage: &Usage2,
        usage_watcher: fdomain_client::fidl::ClientEnd<UsageWatcher2Marker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for UsageReporterProxy {
    type Protocol = UsageReporterMarker;

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

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

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

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

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

    pub fn r#watch(
        &self,
        mut usage: &Usage,
        mut usage_watcher: fdomain_client::fidl::ClientEnd<UsageWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        UsageReporterProxyInterface::r#watch(self, usage, usage_watcher)
    }

    pub fn r#watch2(
        &self,
        mut usage: &Usage2,
        mut usage_watcher: fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageReporterRequestStream {
    type Protocol = UsageReporterMarker;
    type ControlHandle = UsageReporterControlHandle;

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

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

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

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

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

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

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

/// A protocol for setting up watchers of audio usages.
#[derive(Debug)]
pub enum UsageReporterRequest {
    Watch {
        usage: Usage,
        usage_watcher: fdomain_client::fidl::ClientEnd<UsageWatcherMarker>,
        control_handle: UsageReporterControlHandle,
    },
    Watch2 {
        usage: Usage2,
        usage_watcher: fdomain_client::fidl::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,
        fdomain_client::fidl::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,
        fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

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

impl UsageReporterControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for UsageWatcherMarker {
    type Proxy = UsageWatcherProxy;
    type RequestStream = UsageWatcherRequestStream;

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

impl fdomain_client::fidl::Proxy for UsageWatcherProxy {
    type Protocol = UsageWatcherMarker;

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

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

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

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

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

impl UsageWatcherProxyInterface for UsageWatcherProxy {
    type OnStateChangedResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#on_state_changed(
        &self,
        mut usage: &Usage,
        mut state: &UsageState,
    ) -> Self::OnStateChangedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageWatcherRequestStream {
    type Protocol = UsageWatcherMarker;
    type ControlHandle = UsageWatcherControlHandle;

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

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

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

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

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

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

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

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

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

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

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

impl 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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for UsageWatcher2Marker {
    type Proxy = UsageWatcher2Proxy;
    type RequestStream = UsageWatcher2RequestStream;

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

impl fdomain_client::fidl::Proxy for UsageWatcher2Proxy {
    type Protocol = UsageWatcher2Marker;

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

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

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

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

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

impl UsageWatcher2ProxyInterface for UsageWatcher2Proxy {
    type OnStateChangedResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#on_state_changed(
        &self,
        mut usage: &Usage2,
        mut state: &UsageState,
    ) -> Self::OnStateChangedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl fdomain_client::fidl::RequestStream for UsageWatcher2RequestStream {
    type Protocol = UsageWatcher2Marker;
    type ControlHandle = UsageWatcher2ControlHandle;

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

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

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

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

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

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

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

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_media_audio::GainControlMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCapturerGetReferenceClockResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioCapturerGetReferenceClockResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCapturerGetReferenceClockResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::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<
                    fdomain_client::Clock,
                    { fidl::ObjectType::CLOCK.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCapturerGetReferenceClockResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCapturerGetReferenceClockResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Clock, { fidl::ObjectType::CLOCK.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Clock, { fidl::ObjectType::CLOCK.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCapturerSetReferenceClockRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioCapturerSetReferenceClockRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCapturerSetReferenceClockRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::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<
                        fdomain_client::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCapturerSetReferenceClockRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCapturerSetReferenceClockRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Clock,
                            { fidl::ObjectType::CLOCK.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioConsumerBindVolumeControlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioConsumerBindVolumeControlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioConsumerBindVolumeControlRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_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<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioConsumerBindVolumeControlRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioConsumerBindVolumeControlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                volume_control_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_media_audio::VolumeControlMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioConsumerCreateStreamSinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioConsumerCreateStreamSinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioConsumerCreateStreamSinkRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<fidl::encoding::HandleType<fdomain_client::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<fdomain_client::fidl::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<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<AudioStreamType, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Boxed<Compression>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StreamSinkMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioConsumerCreateStreamSinkRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioConsumerCreateStreamSinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffers: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                stream_type: fidl::new_empty!(
                    AudioStreamType,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                compression: fidl::new_empty!(
                    fidl::encoding::Boxed<Compression>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                stream_sink_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StreamSinkMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            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<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffers,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                AudioStreamType,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.stream_type,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<Compression>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.compression,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StreamSinkMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCoreBindUsageVolumeControl2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioCoreBindUsageVolumeControl2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCoreBindUsageVolumeControl2Request,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_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, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreBindUsageVolumeControl2Request,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCoreBindUsageVolumeControl2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage2, fdomain_client::fidl::FDomainResourceDialect),
                volume_control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_media_audio::VolumeControlMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Usage2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCoreBindUsageVolumeControlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioCoreBindUsageVolumeControlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioCoreBindUsageVolumeControlRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_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, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreBindUsageVolumeControlRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCoreBindUsageVolumeControlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage, fdomain_client::fidl::FDomainResourceDialect),
                volume_control: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_media_audio::VolumeControlMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Usage,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<
                        fdomain_fuchsia_media_audio::VolumeControlMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCoreCreateAudioCapturerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioCoreCreateAudioCapturerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioCoreCreateAudioCapturerRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.loopback),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_in_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<bool, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreCreateAudioCapturerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCoreCreateAudioCapturerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                loopback: fidl::new_empty!(bool, fdomain_client::fidl::FDomainResourceDialect),
                audio_in_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const 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,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.loopback,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioCoreCreateAudioCapturerWithConfigurationRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<AudioCoreCreateAudioCapturerWithConfigurationRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AudioCoreCreateAudioCapturerWithConfigurationRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <AudioStreamType as fidl::encoding::ValueTypeMarker>::borrow(&self.stream_type),
                    <AudioCapturerConfiguration as fidl::encoding::ValueTypeMarker>::borrow(&self.configuration),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_capturer_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<AudioStreamType, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                AudioCapturerConfiguration,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioCoreCreateAudioCapturerWithConfigurationRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioCoreCreateAudioCapturerWithConfigurationRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                stream_type: fidl::new_empty!(
                    AudioStreamType,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                configuration: fidl::new_empty!(
                    AudioCapturerConfiguration,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                audio_capturer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioCapturerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioRendererMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioDeviceEnumeratorAddDeviceByChannelRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioDeviceEnumeratorAddDeviceByChannelRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioDeviceEnumeratorAddDeviceByChannelRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::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<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_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>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<bool, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_hardware_audio::StreamConfigMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioDeviceEnumeratorAddDeviceByChannelRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioDeviceEnumeratorAddDeviceByChannelRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_name: fidl::new_empty!(
                    fidl::encoding::BoundedString<256>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                is_input: fidl::new_empty!(bool, fdomain_client::fidl::FDomainResourceDialect),
                channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_hardware_audio::StreamConfigMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            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>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.device_name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                bool,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.is_input,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_hardware_audio::StreamConfigMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioRendererBindGainControlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioRendererBindGainControlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioRendererBindGainControlRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_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<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_media_audio::GainControlMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioRendererBindGainControlRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioRendererBindGainControlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                gain_control_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<
                            fdomain_fuchsia_media_audio::GainControlMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_media_audio::GainControlMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioRendererGetReferenceClockResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioRendererGetReferenceClockResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioRendererGetReferenceClockResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::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<
                    fdomain_client::Clock,
                    { fidl::ObjectType::CLOCK.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioRendererGetReferenceClockResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioRendererGetReferenceClockResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Clock, { fidl::ObjectType::CLOCK.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Clock, { fidl::ObjectType::CLOCK.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AudioRendererSetReferenceClockRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AudioRendererSetReferenceClockRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AudioRendererSetReferenceClockRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::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<
                        fdomain_client::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AudioRendererSetReferenceClockRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for AudioRendererSetReferenceClockRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                reference_clock: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Clock,
                            { fidl::ObjectType::CLOCK.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Clock,
                        { fidl::ObjectType::CLOCK.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ProfileProviderRegisterHandlerWithCapacityRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProfileProviderRegisterHandlerWithCapacityRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderRegisterHandlerWithCapacityRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::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<
                    fdomain_client::Thread,
                    { fidl::ObjectType::THREAD.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<i64, fdomain_client::fidl::FDomainResourceDialect>,
        T3: fidl::encoding::Encode<f32, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            ProfileProviderRegisterHandlerWithCapacityRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for ProfileProviderRegisterHandlerWithCapacityRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                period: fidl::new_empty!(i64, fdomain_client::fidl::FDomainResourceDialect),
                capacity: fidl::new_empty!(f32, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            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<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.thread_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                i64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.period,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                f32,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ProfileProviderRegisterMemoryRangeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProfileProviderRegisterMemoryRangeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderRegisterMemoryRangeRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::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<
                    fdomain_client::Vmar,
                    { fidl::ObjectType::VMAR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProfileProviderRegisterMemoryRangeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for ProfileProviderRegisterMemoryRangeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.vmar_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ProfileProviderUnregisterHandlerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProfileProviderUnregisterHandlerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderUnregisterHandlerRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::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<
                    fdomain_client::Thread,
                    { fidl::ObjectType::THREAD.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProfileProviderUnregisterHandlerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for ProfileProviderUnregisterHandlerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.thread_handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ProfileProviderUnregisterMemoryRangeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProfileProviderUnregisterMemoryRangeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProfileProviderUnregisterMemoryRangeRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::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<
                    fdomain_client::Vmar,
                    { fidl::ObjectType::VMAR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProfileProviderUnregisterMemoryRangeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for ProfileProviderUnregisterMemoryRangeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut SessionAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionAudioConsumerFactoryCreateAudioConsumerRequest>(
                offset,
            );
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SessionAudioConsumerFactoryCreateAudioConsumerRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.session_id),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_consumer_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            SessionAudioConsumerFactoryCreateAudioConsumerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session_id: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                audio_consumer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                StreamBufferPartialSettings,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut StreamProcessorSetOutputBufferPartialSettingsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<StreamProcessorSetOutputBufferPartialSettingsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StreamProcessorSetOutputBufferPartialSettingsRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <StreamBufferPartialSettings as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.output_settings),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                StreamBufferPartialSettings,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            StreamProcessorSetOutputBufferPartialSettingsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for StreamProcessorSetOutputBufferPartialSettingsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                output_settings: fidl::new_empty!(
                    StreamBufferPartialSettings,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                AudioRenderUsage2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut UsageAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<UsageAudioConsumerFactoryCreateAudioConsumerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageAudioConsumerFactoryCreateAudioConsumerRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.audio_consumer_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<AudioRenderUsage, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageAudioConsumerFactoryCreateAudioConsumerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for UsageAudioConsumerFactoryCreateAudioConsumerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(
                    AudioRenderUsage,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                audio_consumer_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                AudioRenderUsage,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<AudioConsumerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut UsageGainReporterRegisterListener2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UsageGainReporterRegisterListener2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                UsageGainReporterRegisterListener2Request,
                fdomain_client::fidl::FDomainResourceDialect,
            >::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<
                        fdomain_client::fidl::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>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<Usage2, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageGainReporterRegisterListener2Request,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for UsageGainReporterRegisterListener2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_unique_id: fidl::new_empty!(
                    fidl::encoding::BoundedString<36>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                usage: fidl::new_empty!(Usage2, fdomain_client::fidl::FDomainResourceDialect),
                usage_gain_listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.device_unique_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Usage2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut UsageGainReporterRegisterListenerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UsageGainReporterRegisterListenerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                UsageGainReporterRegisterListenerRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::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<
                        fdomain_client::fidl::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>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<Usage, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageGainReporterRegisterListenerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for UsageGainReporterRegisterListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                device_unique_id: fidl::new_empty!(
                    fidl::encoding::BoundedString<36>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                usage: fidl::new_empty!(Usage, fdomain_client::fidl::FDomainResourceDialect),
                usage_gain_listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.device_unique_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Usage,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageGainListenerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut UsageReporterWatch2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UsageReporterWatch2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageReporterWatch2Request, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <Usage2 as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcher2Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage2, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcher2Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageReporterWatch2Request,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for UsageReporterWatch2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage2, fdomain_client::fidl::FDomainResourceDialect),
                usage_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcher2Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Usage2,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcher2Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut UsageReporterWatchRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UsageReporterWatchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UsageReporterWatchRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <Usage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.usage_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Usage, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UsageReporterWatchRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for UsageReporterWatchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(Usage, fdomain_client::fidl::FDomainResourceDialect),
                usage_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcherMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Usage,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.usage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<UsageWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut StreamBufferPartialSettings
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_sysmem::BufferCollectionTokenMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.sysmem_token.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_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<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.sysmem2_token.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_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, fdomain_client::fidl::FDomainResourceDialect>
        for StreamBufferPartialSettings
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

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

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <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, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_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<
                            fdomain_client::fidl::ClientEnd<
                                fdomain_fuchsia_sysmem::BufferCollectionTokenMarker,
                            >,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_sysmem::BufferCollectionTokenMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_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<
                            fdomain_client::fidl::ClientEnd<
                                fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                            >,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl StreamProcessorAddBufferRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.buffer {
                return 5;
            }
            if let Some(_) = self.buffer_index {
                return 4;
            }
            if let Some(_) = self.buffer_lifetime_ordinal {
                return 3;
            }
            if let Some(_) = self.buffer_constraints_version_ordinal {
                return 2;
            }
            if let Some(_) = self.port {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StreamProcessorAddBufferRequest {
        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 StreamProcessorAddBufferRequest {
        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<
            StreamProcessorAddBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut StreamProcessorAddBufferRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamProcessorAddBufferRequest>(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::<
                Port,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.port.as_ref().map(<Port as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Port 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.port.get_or_insert_with(|| {
                    fidl::new_empty!(Port, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Port,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

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

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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.buffer_index.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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 = <fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.buffer.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl StreamProcessorParticipateInBufferAllocationRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.allow_single_buffer {
                return 5;
            }
            if let Some(_) = self.buffer_lifetime_ordinal {
                return 4;
            }
            if let Some(_) = self.sysmem2_token {
                return 3;
            }
            if let Some(_) = self.buffer_constraints_version_ordinal {
                return 2;
            }
            if let Some(_) = self.port {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StreamProcessorParticipateInBufferAllocationRequest {
        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 StreamProcessorParticipateInBufferAllocationRequest {
        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<
            StreamProcessorParticipateInBufferAllocationRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut StreamProcessorParticipateInBufferAllocationRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<StreamProcessorParticipateInBufferAllocationRequest>(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::<
                Port,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.port.as_ref().map(<Port as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.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::<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.sysmem2_token.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                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 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::<
                bool,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.allow_single_buffer
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Port 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.port.get_or_insert_with(|| {
                    fidl::new_empty!(Port, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Port,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_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<
                            fdomain_client::fidl::ClientEnd<
                                fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                            >,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_sysmem2::BufferCollectionTokenMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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 =
                    <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, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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 =
                    <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.allow_single_buffer.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl StreamProcessorRemoveBufferRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.buffer_index {
                return 3;
            }
            if let Some(_) = self.buffer_lifetime_ordinal {
                return 2;
            }
            if let Some(_) = self.port {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StreamProcessorRemoveBufferRequest {
        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 StreamProcessorRemoveBufferRequest {
        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<
            StreamProcessorRemoveBufferRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut StreamProcessorRemoveBufferRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamProcessorRemoveBufferRequest>(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::<
                Port,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.port.as_ref().map(<Port as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Port 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.port.get_or_insert_with(|| {
                    fidl::new_empty!(Port, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Port,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <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.buffer_index.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}