fdomain_fuchsia_sysmem/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AllocatorAllocateNonSharedCollectionRequest {
    pub collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AllocatorAllocateSharedCollectionRequest {
    pub token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AllocatorBindSharedCollectionRequest {
    pub token: fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
    pub buffer_collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AllocatorConnectToSysmem2AllocatorRequest {
    pub allocator_request:
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_sysmem2::AllocatorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionAttachLifetimeTrackingRequest {
    pub server_end: fdomain_client::EventPair,
    pub buffers_remaining: u32,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionAttachTokenRequest {
    pub rights_attenuation_mask: u32,
    pub token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
}

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

/// Deprecated. Use ['fuchsia.sysmem2.BufferCollectionInfo'].
///
/// This type is deprecated for new code but still used by some camera code.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionInfo {
    /// The number of buffers in the collection.
    pub buffer_count: u32,
    /// Describes how the contents of buffers are represented.
    /// All buffers within the collection have the same format.
    pub format: BufferFormat,
    /// VMO handles for each buffer in the collection.
    /// The VMOs are only present when the buffers are backed by VMOs.
    ///
    /// If present, all the VMOs after `buffer_count` are invalid handles.
    /// All buffer VMO handles have identical size and access rights.
    /// The VMO access rights are determined based on the usages which the
    /// client specified when allocating the buffer collection.  For example,
    /// a client which expressed a read-only usage will receive VMOs without
    /// write rights.
    pub vmos: [Option<fdomain_client::Vmo>; 64],
    /// The size of each VMO provided.
    /// This property is only present when the buffers are backed by VMOs.
    pub vmo_size: u64,
}

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

/// Information about a buffer collection and its buffers.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionInfo2 {
    /// The total number of buffers.
    pub buffer_count: u32,
    /// These settings apply to all the buffers in the initial buffer allocation.
    pub settings: SingleBufferSettings,
    /// VMO handles (and vmo_usable_start offset) for each buffer in the
    /// collection.
    ///
    /// If present, all the VMOs at or after index `buffer_count` are invalid
    /// (0) handles.
    ///
    /// All buffer VMO handles have identical size and access rights.  The size
    /// is in settings.buffer_settings.size_bytes.
    ///
    /// The VMO access rights are determined based on the usages which the
    /// client specified when allocating the buffer collection.  For example,
    /// a client which expressed a read-only usage will receive VMOs without
    /// write rights.  In addition, the rights can be attenuated by the
    /// parameter to BufferCollectionToken.Duplicate() calls.
    pub buffers: [VmoBuffer; 64],
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenCreateBufferCollectionTokenGroupRequest {
    pub group_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenDuplicateRequest {
    pub rights_attenuation_mask: u32,
    pub token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenDuplicateSyncResponse {
    pub tokens: Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenGroupCreateChildrenSyncResponse {
    pub tokens: Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionWaitForBuffersAllocatedResponse {
    pub status: i32,
    pub buffer_collection_info: BufferCollectionInfo2,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeGetNodeRefResponse {
    pub node_ref: fdomain_client::Event,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeIsAlternateForRequest {
    pub node_ref: fdomain_client::Event,
}

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

/// There is no current replacement for this type, but if your use case needs
/// incremental buffer allocation within a single collection, please reach out.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SingleBufferInfo {
    pub settings: SingleBufferSettings,
    pub buffer: VmoBuffer,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VmoBuffer {
    /// The same VMO can be used by more than one CodecBuffer (only of the same
    /// buffer_lifetime_ordinal), but each vmo handle must be a separate handle.
    ///
    /// The vmo field can be 0 if this is a VmoBuffer in BufferCollectionInfo_2
    /// that's at or beyond BufferCollectionInfo_2.buffer_count.
    pub vmo: Option<fdomain_client::Vmo>,
    /// Offset within the VMO of the first usable byte.  Must be < the VMO's
    /// size in bytes, and leave sufficient room for
    /// BufferMemorySettings.size_bytes before the end of the VMO.
    pub vmo_usable_start: u64,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionTokenGroupCreateChildRequest {
    /// Must be set.
    pub token_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>>,
    /// If not set, the default is ZX_RIGHT_SAME_RIGHTS.
    pub rights_attenuation_mask: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fdomain_client::fidl::ProtocolMarker for AllocatorMarker {
    type Proxy = AllocatorProxy;
    type RequestStream = AllocatorRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sysmem.Allocator";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for AllocatorMarker {}

pub trait AllocatorProxyInterface: Send + Sync {
    fn r#allocate_non_shared_collection(
        &self,
        collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#allocate_shared_collection(
        &self,
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#bind_shared_collection(
        &self,
        token: fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
        buffer_collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error>;
    type ValidateBufferCollectionTokenResponseFut: std::future::Future<Output = Result<bool, fidl::Error>>
        + Send;
    fn r#validate_buffer_collection_token(
        &self,
        token_server_koid: u64,
    ) -> Self::ValidateBufferCollectionTokenResponseFut;
    fn r#set_debug_client_info(&self, name: &str, id: u64) -> Result<(), fidl::Error>;
    fn r#connect_to_sysmem2_allocator(
        &self,
        allocator_request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_sysmem2::AllocatorMarker,
        >,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for AllocatorProxy {
    type Protocol = AllocatorMarker;

    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 AllocatorProxy {
    /// Create a new Proxy for fuchsia.sysmem/Allocator.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <AllocatorMarker 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) -> AllocatorEventStream {
        AllocatorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Allocates a BufferCollection on behalf of a single client (aka initiator)
    /// who is also the only participant (from the point of view of sysmem).
    ///
    /// This call exists mainly for temp/testing purposes.  This call skips the
    /// BufferCollectionToken stage, so there's no way to allow another
    /// participant to specify its constraints.
    ///
    /// Real clients are encouraged to use AllocateSharedCollection() instead,
    /// and to let relevant participants directly convey their own constraints to
    /// sysmem.
    ///
    /// `collection_request` is the server end of the BufferCollection FIDL
    /// channel.  The client can call SetConstraints() and then
    /// WaitForBuffersAllocated() on the client end of this channel to specify
    /// constraints and then determine success/failure and get the
    /// BufferCollectionInfo_2 for the BufferCollection.  The client should also
    /// keep the client end of this channel open while using the
    /// BufferCollection, and should notice when this channel closes and stop
    /// using the BufferCollection ASAP.
    pub fn r#allocate_non_shared_collection(
        &self,
        mut collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#allocate_non_shared_collection(self, collection_request)
    }

    /// Creates a logical BufferCollectionToken which can be shared among
    /// participants (using BufferCollectionToken.Duplicate()), and then
    /// converted into a BufferCollection using BindSharedCollection().
    ///
    /// Success/failure to populate the BufferCollection with buffers is
    /// determined via the BufferCollection interface.
    pub fn r#allocate_shared_collection(
        &self,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#allocate_shared_collection(self, token_request)
    }

    /// Convert a BufferCollectionToken into a connection to the logical
    /// BufferCollection.  The BufferCollection hasn't yet been populated with
    /// buffers - the participant must first also send SetConstraints() via the
    /// client end of buffer_collection.
    ///
    /// All BufferCollectionToken(s) duplicated from a logical
    /// BufferCollectionToken created via AllocateSharedCollection() must be
    /// turned in via BindSharedCollection() before the logical BufferCollection
    /// will be populated with buffers.
    ///
    /// `token` the client endpoint of a channel whose server end was sent to
    /// sysmem using AllocateSharedCollection or whose server end was sent to
    /// sysmem using BufferCollectionToken.Duplicate().  The token is being
    /// "exchanged" for a channel to the logical BufferCollection.
    ///
    /// `buffer_collection_request` the server end of a BufferCollection
    /// channel.  The sender retains the client end as usual.  The
    /// BufferCollection channel is a single participant's connection to the
    /// logical BufferCollection.  There typically will be other participants
    /// with their own BufferCollection channel to the logical BufferCollection.
    pub fn r#bind_shared_collection(
        &self,
        mut token: fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
        mut buffer_collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#bind_shared_collection(self, token, buffer_collection_request)
    }

    /// Validate that a BufferCollectionToken is known to the sysmem server.
    ///
    /// This can be used in cases where BindSharedCollection() won't be called
    /// until after BufferCollectionToken.Duplicate() +
    /// BufferCollectionToken.Sync(), when the client code wants to know earlier
    /// whether an incoming token is valid (so far).
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't known to
    /// sysmem risks the Sync() hanging forever.
    ///
    /// Given that an incoming token can become invalid at any time if any
    /// participant drops their BufferCollectionToken(s) or BufferCollection(s),
    /// authors of client code are encouraged to consider not calling
    /// ValidateBufferCollectionToken() and instead dealing with async failure
    /// of the BufferCollection.Sync() after all the
    /// BufferCollectionToken.Duplicate() and BindSharedCollection() (before
    /// sending any duplicate tokens to other processes).
    ///
    /// Regardless of the result of this call, this call has no effect on the
    /// token with the referenced koid.
    ///
    /// A true result from this call doesn't guarantee that the token remains
    /// valid for any duration afterwards.
    ///
    /// Client code will zx_object_get_info() on the client's token handle,
    /// passing ZX_INFO_HANDLE_BASIC and getting back the related_koid
    /// which then gets passed to ValidateBufferCollectionToken().
    ///
    /// If ValidateBufferCollectionToken() returns true, the token was known at
    /// the time the sysmem server processed the call, but may no longer be
    /// valid/known by the time the client code receives the response.
    ///
    /// If ValidateBufferCollectionToken() returns false, the token wasn't known
    /// at the time the sysmem server processed the call, but the token may
    /// become known by the time the client code receives the response.  However
    /// client code is not required to mitigate the possibility that the token
    /// may become known late, since the source of the token should have synced
    /// the token to sysmem before sending the token to the client code.
    ///
    /// If calling ValidateBufferCollectionToken() fails in some way, there will
    /// be a zx_status_t from the FIDL layer.
    ///
    /// `token_server_koid` the koid of the server end of a channel that might
    /// be a BufferCollectionToken channel.  This can be obtained from
    /// zx_object_get_info() ZX_INFO_HANDLE_BASIC related_koid.
    pub fn r#validate_buffer_collection_token(
        &self,
        mut token_server_koid: u64,
    ) -> fidl::client::QueryResponseFut<bool, fdomain_client::fidl::FDomainResourceDialect> {
        AllocatorProxyInterface::r#validate_buffer_collection_token(self, token_server_koid)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// This information is propagated to all BufferCollections created using
    /// BindSharedCollection() or AllocateNonSharedCollection() from this
    /// allocator. It does not affect BufferCollectionTokens, since they are
    /// often passed cross-process and should have their names managed manually.
    pub fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#set_debug_client_info(self, name, id)
    }

    /// This allows creating a sysmem2 `Allocator` given a sysmem(1)
    /// `Allocator`.
    ///
    /// This is mainly useful in situations where library code is handed a
    /// sysmem(1) allocator, but the library code has been updated to use
    /// sysmem2. Typically the library will provide a way to pass in a sysmem2
    /// `Allocator` instead, but client code isn't always in the same repo, so
    /// this message allows the library to still accept the sysmem(1) Allocator
    /// temporarily.
    ///
    /// The info set via `SetDebugClientInfo` (if any) is copied to the sysmem2
    /// `Allocator`.
    pub fn r#connect_to_sysmem2_allocator(
        &self,
        mut allocator_request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_sysmem2::AllocatorMarker,
        >,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#connect_to_sysmem2_allocator(self, allocator_request)
    }
}

impl AllocatorProxyInterface for AllocatorProxy {
    fn r#allocate_non_shared_collection(
        &self,
        mut collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorAllocateNonSharedCollectionRequest>(
            (collection_request,),
            0x20f79299bbb4d2c6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#allocate_shared_collection(
        &self,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorAllocateSharedCollectionRequest>(
            (token_request,),
            0x7a757a57bfda0f71,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#bind_shared_collection(
        &self,
        mut token: fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
        mut buffer_collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorBindSharedCollectionRequest>(
            (token, buffer_collection_request),
            0x146eca7ec46ff4ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ValidateBufferCollectionTokenResponseFut =
        fidl::client::QueryResponseFut<bool, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#validate_buffer_collection_token(
        &self,
        mut token_server_koid: u64,
    ) -> Self::ValidateBufferCollectionTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<bool, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AllocatorValidateBufferCollectionTokenResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x575b279b0236faea,
            >(_buf?)?;
            Ok(_response.is_known)
        }
        self.client.send_query_and_decode::<AllocatorValidateBufferCollectionTokenRequest, bool>(
            (token_server_koid,),
            0x575b279b0236faea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorSetDebugClientInfoRequest>(
            (name, id),
            0x419f0d5b30728b26,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_to_sysmem2_allocator(
        &self,
        mut allocator_request: fdomain_client::fidl::ServerEnd<
            fdomain_fuchsia_sysmem2::AllocatorMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorConnectToSysmem2AllocatorRequest>(
            (allocator_request,),
            0x13db3e3abac2e24,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for AllocatorRequestStream {
    type Protocol = AllocatorMarker;
    type ControlHandle = AllocatorControlHandle;

    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 {
        AllocatorControlHandle { 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 AllocatorRequestStream {
    type Item = Result<AllocatorRequest, 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 AllocatorRequestStream 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 {
                    0x20f79299bbb4d2c6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorAllocateNonSharedCollectionRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorAllocateNonSharedCollectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::AllocateNonSharedCollection {
                            collection_request: req.collection_request,

                            control_handle,
                        })
                    }
                    0x7a757a57bfda0f71 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorAllocateSharedCollectionRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorAllocateSharedCollectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::AllocateSharedCollection {
                            token_request: req.token_request,

                            control_handle,
                        })
                    }
                    0x146eca7ec46ff4ee => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorBindSharedCollectionRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorBindSharedCollectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::BindSharedCollection {
                            token: req.token,
                            buffer_collection_request: req.buffer_collection_request,

                            control_handle,
                        })
                    }
                    0x575b279b0236faea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorValidateBufferCollectionTokenRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorValidateBufferCollectionTokenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::ValidateBufferCollectionToken {
                            token_server_koid: req.token_server_koid,

                            responder: AllocatorValidateBufferCollectionTokenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x419f0d5b30728b26 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorSetDebugClientInfoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorSetDebugClientInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::SetDebugClientInfo {
                            name: req.name,
                            id: req.id,

                            control_handle,
                        })
                    }
                    0x13db3e3abac2e24 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorConnectToSysmem2AllocatorRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorConnectToSysmem2AllocatorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::ConnectToSysmem2Allocator {
                            allocator_request: req.allocator_request,

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

/// Allocates system memory buffers.
#[derive(Debug)]
pub enum AllocatorRequest {
    /// Allocates a BufferCollection on behalf of a single client (aka initiator)
    /// who is also the only participant (from the point of view of sysmem).
    ///
    /// This call exists mainly for temp/testing purposes.  This call skips the
    /// BufferCollectionToken stage, so there's no way to allow another
    /// participant to specify its constraints.
    ///
    /// Real clients are encouraged to use AllocateSharedCollection() instead,
    /// and to let relevant participants directly convey their own constraints to
    /// sysmem.
    ///
    /// `collection_request` is the server end of the BufferCollection FIDL
    /// channel.  The client can call SetConstraints() and then
    /// WaitForBuffersAllocated() on the client end of this channel to specify
    /// constraints and then determine success/failure and get the
    /// BufferCollectionInfo_2 for the BufferCollection.  The client should also
    /// keep the client end of this channel open while using the
    /// BufferCollection, and should notice when this channel closes and stop
    /// using the BufferCollection ASAP.
    AllocateNonSharedCollection {
        collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
        control_handle: AllocatorControlHandle,
    },
    /// Creates a logical BufferCollectionToken which can be shared among
    /// participants (using BufferCollectionToken.Duplicate()), and then
    /// converted into a BufferCollection using BindSharedCollection().
    ///
    /// Success/failure to populate the BufferCollection with buffers is
    /// determined via the BufferCollection interface.
    AllocateSharedCollection {
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        control_handle: AllocatorControlHandle,
    },
    /// Convert a BufferCollectionToken into a connection to the logical
    /// BufferCollection.  The BufferCollection hasn't yet been populated with
    /// buffers - the participant must first also send SetConstraints() via the
    /// client end of buffer_collection.
    ///
    /// All BufferCollectionToken(s) duplicated from a logical
    /// BufferCollectionToken created via AllocateSharedCollection() must be
    /// turned in via BindSharedCollection() before the logical BufferCollection
    /// will be populated with buffers.
    ///
    /// `token` the client endpoint of a channel whose server end was sent to
    /// sysmem using AllocateSharedCollection or whose server end was sent to
    /// sysmem using BufferCollectionToken.Duplicate().  The token is being
    /// "exchanged" for a channel to the logical BufferCollection.
    ///
    /// `buffer_collection_request` the server end of a BufferCollection
    /// channel.  The sender retains the client end as usual.  The
    /// BufferCollection channel is a single participant's connection to the
    /// logical BufferCollection.  There typically will be other participants
    /// with their own BufferCollection channel to the logical BufferCollection.
    BindSharedCollection {
        token: fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
        buffer_collection_request: fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
        control_handle: AllocatorControlHandle,
    },
    /// Validate that a BufferCollectionToken is known to the sysmem server.
    ///
    /// This can be used in cases where BindSharedCollection() won't be called
    /// until after BufferCollectionToken.Duplicate() +
    /// BufferCollectionToken.Sync(), when the client code wants to know earlier
    /// whether an incoming token is valid (so far).
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't known to
    /// sysmem risks the Sync() hanging forever.
    ///
    /// Given that an incoming token can become invalid at any time if any
    /// participant drops their BufferCollectionToken(s) or BufferCollection(s),
    /// authors of client code are encouraged to consider not calling
    /// ValidateBufferCollectionToken() and instead dealing with async failure
    /// of the BufferCollection.Sync() after all the
    /// BufferCollectionToken.Duplicate() and BindSharedCollection() (before
    /// sending any duplicate tokens to other processes).
    ///
    /// Regardless of the result of this call, this call has no effect on the
    /// token with the referenced koid.
    ///
    /// A true result from this call doesn't guarantee that the token remains
    /// valid for any duration afterwards.
    ///
    /// Client code will zx_object_get_info() on the client's token handle,
    /// passing ZX_INFO_HANDLE_BASIC and getting back the related_koid
    /// which then gets passed to ValidateBufferCollectionToken().
    ///
    /// If ValidateBufferCollectionToken() returns true, the token was known at
    /// the time the sysmem server processed the call, but may no longer be
    /// valid/known by the time the client code receives the response.
    ///
    /// If ValidateBufferCollectionToken() returns false, the token wasn't known
    /// at the time the sysmem server processed the call, but the token may
    /// become known by the time the client code receives the response.  However
    /// client code is not required to mitigate the possibility that the token
    /// may become known late, since the source of the token should have synced
    /// the token to sysmem before sending the token to the client code.
    ///
    /// If calling ValidateBufferCollectionToken() fails in some way, there will
    /// be a zx_status_t from the FIDL layer.
    ///
    /// `token_server_koid` the koid of the server end of a channel that might
    /// be a BufferCollectionToken channel.  This can be obtained from
    /// zx_object_get_info() ZX_INFO_HANDLE_BASIC related_koid.
    ValidateBufferCollectionToken {
        token_server_koid: u64,
        responder: AllocatorValidateBufferCollectionTokenResponder,
    },
    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// This information is propagated to all BufferCollections created using
    /// BindSharedCollection() or AllocateNonSharedCollection() from this
    /// allocator. It does not affect BufferCollectionTokens, since they are
    /// often passed cross-process and should have their names managed manually.
    SetDebugClientInfo { name: String, id: u64, control_handle: AllocatorControlHandle },
    /// This allows creating a sysmem2 `Allocator` given a sysmem(1)
    /// `Allocator`.
    ///
    /// This is mainly useful in situations where library code is handed a
    /// sysmem(1) allocator, but the library code has been updated to use
    /// sysmem2. Typically the library will provide a way to pass in a sysmem2
    /// `Allocator` instead, but client code isn't always in the same repo, so
    /// this message allows the library to still accept the sysmem(1) Allocator
    /// temporarily.
    ///
    /// The info set via `SetDebugClientInfo` (if any) is copied to the sysmem2
    /// `Allocator`.
    ConnectToSysmem2Allocator {
        allocator_request:
            fdomain_client::fidl::ServerEnd<fdomain_fuchsia_sysmem2::AllocatorMarker>,
        control_handle: AllocatorControlHandle,
    },
}

impl AllocatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_allocate_non_shared_collection(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<BufferCollectionMarker>, AllocatorControlHandle)>
    {
        if let AllocatorRequest::AllocateNonSharedCollection {
            collection_request,
            control_handle,
        } = self
        {
            Some((collection_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_allocate_shared_collection(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        AllocatorControlHandle,
    )> {
        if let AllocatorRequest::AllocateSharedCollection { token_request, control_handle } = self {
            Some((token_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_shared_collection(
        self,
    ) -> Option<(
        fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>,
        fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
        AllocatorControlHandle,
    )> {
        if let AllocatorRequest::BindSharedCollection {
            token,
            buffer_collection_request,
            control_handle,
        } = self
        {
            Some((token, buffer_collection_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_validate_buffer_collection_token(
        self,
    ) -> Option<(u64, AllocatorValidateBufferCollectionTokenResponder)> {
        if let AllocatorRequest::ValidateBufferCollectionToken { token_server_koid, responder } =
            self
        {
            Some((token_server_koid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_client_info(self) -> Option<(String, u64, AllocatorControlHandle)> {
        if let AllocatorRequest::SetDebugClientInfo { name, id, control_handle } = self {
            Some((name, id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_sysmem2_allocator(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_sysmem2::AllocatorMarker>,
        AllocatorControlHandle,
    )> {
        if let AllocatorRequest::ConnectToSysmem2Allocator { allocator_request, control_handle } =
            self
        {
            Some((allocator_request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AllocatorRequest::AllocateNonSharedCollection { .. } => {
                "allocate_non_shared_collection"
            }
            AllocatorRequest::AllocateSharedCollection { .. } => "allocate_shared_collection",
            AllocatorRequest::BindSharedCollection { .. } => "bind_shared_collection",
            AllocatorRequest::ValidateBufferCollectionToken { .. } => {
                "validate_buffer_collection_token"
            }
            AllocatorRequest::SetDebugClientInfo { .. } => "set_debug_client_info",
            AllocatorRequest::ConnectToSysmem2Allocator { .. } => "connect_to_sysmem2_allocator",
        }
    }
}

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

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

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

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

impl AllocatorControlHandle {}

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

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

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

    fn send_raw(&self, mut is_known: bool) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AllocatorValidateBufferCollectionTokenResponse>(
            (is_known,),
            self.tx_id,
            0x575b279b0236faea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for BufferCollectionMarker {
    type Proxy = BufferCollectionProxy;
    type RequestStream = BufferCollectionRequestStream;

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

pub trait BufferCollectionProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, priority: u32, name: &str) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(&self, name: &str, id: u64) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(&self, deadline: i64) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<fdomain_client::Event, fidl::Error>>
        + Send;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut;
    type IsAlternateForResponseFut: std::future::Future<Output = Result<NodeIsAlternateForResult, fidl::Error>>
        + Send;
    fn r#is_alternate_for(
        &self,
        node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut;
    fn r#set_constraints(
        &self,
        has_constraints: bool,
        constraints: &BufferCollectionConstraints,
    ) -> Result<(), fidl::Error>;
    type WaitForBuffersAllocatedResponseFut: std::future::Future<Output = Result<(i32, BufferCollectionInfo2), fidl::Error>>
        + Send;
    fn r#wait_for_buffers_allocated(&self) -> Self::WaitForBuffersAllocatedResponseFut;
    type CheckBuffersAllocatedResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#check_buffers_allocated(&self) -> Self::CheckBuffersAllocatedResponseFut;
    fn r#attach_token(
        &self,
        rights_attenuation_mask: u32,
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#attach_lifetime_tracking(
        &self,
        server_end: fdomain_client::EventPair,
        buffers_remaining: u32,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for BufferCollectionProxy {
    type Protocol = BufferCollectionMarker;

    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 BufferCollectionProxy {
    /// Create a new Proxy for fuchsia.sysmem/BufferCollection.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <BufferCollectionMarker 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) -> BufferCollectionEventStream {
        BufferCollectionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionProxyInterface::r#sync(self)
    }

    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#close(self)
    }

    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    pub fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_name(self, priority, name)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    pub fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_debug_client_info(self, name, id)
    }

    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    pub fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_debug_timeout_log_deadline(self, deadline)
    }

    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#get_node_ref(self)
    }

    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    pub fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#is_alternate_for(self, node_ref)
    }

    /// Provide BufferCollectionConstraints to the logical BufferCollection.
    ///
    /// A participant may only call SetConstraints() once.
    ///
    /// Sometimes the initiator is a participant only in the sense of wanting to
    /// keep an eye on success/failure to populate with buffers, and zx.Status
    /// on failure.  In that case, `has_constraints` can be false, and
    /// `constraints` will be ignored.
    ///
    /// VMO handles will not be provided to the client that sends null
    /// constraints - that can be intentional for an initiator that doesn't need
    /// VMO handles.  Not having VMO handles doesn't prevent the initator from
    /// adjusting which portion of a buffer is considered valid and similar, but
    /// the initiator can't hold a VMO handle open to prevent the logical
    /// BufferCollection from cleaning up if the logical BufferCollection needs
    /// to go away regardless of the initiator's degree of involvement for
    /// whatever reason.
    ///
    /// For population of buffers to be attempted, all holders of a
    /// BufferCollection client channel need to call SetConstraints() before
    /// sysmem will attempt to allocate buffers.
    ///
    /// `has_constraints` if false, the constraints are effectively null, and
    /// `constraints` are ignored.  The sender of null constraints won't get any
    /// VMO handles in BufferCollectionInfo, but can still find out how many
    /// buffers were allocated and can still refer to buffers by their
    /// buffer_index.
    ///
    /// `constraints` are constraints on the buffer collection.
    pub fn r#set_constraints(
        &self,
        mut has_constraints: bool,
        mut constraints: &BufferCollectionConstraints,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_constraints(self, has_constraints, constraints)
    }

    /// This request completes when buffers have been allocated, responds with
    /// some failure detail if allocation has been attempted but failed.
    ///
    /// The following must occur before buffers will be allocated:
    ///   * All BufferCollectionToken(s) of the logical BufferCollectionToken
    ///     must be turned in via BindSharedCollection().
    ///   * All BufferCollection(s) of the logical BufferCollection must have
    ///     had SetConstraints() sent to them.
    ///
    /// Returns `ZX_OK` if successful.
    /// Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
    /// fulfilled due to resource exhaustion.
    /// Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
    /// obtain the buffers it requested.
    /// Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
    /// Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
    /// satisfied, perhaps due to hardware limitations.
    ///
    /// `buffer_collection_info` has the VMO handles and other related info.
    pub fn r#wait_for_buffers_allocated(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, BufferCollectionInfo2),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#wait_for_buffers_allocated(self)
    }

    /// This returns the same result code as WaitForBuffersAllocated if the
    /// buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
    /// if WaitForBuffersAllocated would block.
    pub fn r#check_buffers_allocated(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionProxyInterface::r#check_buffers_allocated(self)
    }

    /// Create a new token, for trying to add a new participant to an existing
    /// collection, if the existing collection's buffer counts, constraints,
    /// and participants allow.
    ///
    /// This can be useful in replacing a failed participant, and/or in
    /// adding/re-adding a participant after buffers have already been
    /// allocated.
    ///
    /// Failure of an attached token / collection does not propagate to the
    /// parent of the attached token.  Failure does propagate from a normal
    /// child of a dispensable token to the dispensable token.  Failure
    /// of a child is blocked from reaching its parent if the child is attached,
    /// or if the child is dispensable and the failure occurred after logical
    /// allocation.
    ///
    /// An initiator may in some scenarios choose to initially use a dispensable
    /// token for a given instance of a participant, and then later if the first
    /// instance of that participant fails, a new second instance of that
    /// participant my be given a token created with AttachToken().
    ///
    /// From the point of view of the client end of the BufferCollectionToken
    /// channel, the token acts like any other token.  The client can
    /// Duplicate() the token as needed, and can send the token to a different
    /// process.  The token should be converted to a BufferCollection channel
    /// as normal by calling BindSharedCollection().  SetConstraints() should
    /// be called on that BufferCollection channel.
    ///
    /// A success result from WaitForBuffersAllocated() means the new
    /// participant's constraints were satisfiable using the already-existing
    /// buffer collection, the already-established BufferCollectionInfo
    /// including image format constraints, and the already-existing other
    /// participants and their buffer counts.  A failure result means the new
    /// participant's constraints cannot be satisfied using the existing
    /// buffer collection and its already-logically-allocated participants.
    /// Creating a new collection instead may allow all participant's
    /// constraints to be satisfied, assuming SetDispensable() is used in place
    /// of AttachToken(), or a normal token is used.
    ///
    /// A token created with AttachToken() performs constraints aggregation with
    /// all constraints currently in effect on the buffer collection, plus the
    /// attached token under consideration plus child tokens under the attached
    /// token which are not themselves an attached token or under such a token.
    ///
    /// Allocation of buffer_count to min_buffer_count_for_camping etc is
    /// first-come first-served, but a child can't logically allocate before
    /// all its parents have sent SetConstraints().
    ///
    /// See also SetDispensable(), which in contrast to AttachToken(), has the
    /// created token + children participate in constraints aggregation along
    /// with its parent.
    ///
    /// The newly created token needs to be Sync()ed to sysmem before the new
    /// token can be passed to BindSharedCollection().  The Sync() of the new
    /// token can be accomplished with BufferCollection.Sync() on this
    /// BufferCollection.  Alternately BufferCollectionToken.Sync() on the new
    /// token also works.  A BufferCollectionToken.Sync() can be started after
    /// any BufferCollectionToken.Duplicate() messages have been sent via the
    /// newly created token, to also sync those additional tokens to sysmem
    /// using a single round-trip.
    ///
    /// These values for rights_attenuation_mask result in no attenuation (note
    /// that 0 is not on this list; 0 will output an ERROR to the system log
    /// to help diagnose the bug in client code):
    ///   * ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   * 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    pub fn r#attach_token(
        &self,
        mut rights_attenuation_mask: u32,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#attach_token(self, rights_attenuation_mask, token_request)
    }

    /// AttachLifetimeTracking:
    ///
    /// AttachLifetimeTracking() is intended to allow a client to wait until an
    /// old logical buffer collection is fully or mostly deallocated before
    /// attempting allocation of a new logical buffer collection.
    ///
    /// Attach an eventpair endpoint to the logical buffer collection, so that
    /// the server_end will be closed when the number of buffers allocated
    /// drops to 'buffers_remaining'.  The server_end won't close until after
    /// logical allocation has completed.
    ///
    /// If logical allocation fails, such as for an attached sub-tree (using
    /// AttachToken()), the server_end will close during that failure regardless
    /// of the number of buffers potenitally allocated in the overall logical
    /// buffer collection.
    ///
    /// The lifetime signalled by this event includes asynchronous cleanup of
    /// allocated buffers, and this asynchronous cleanup cannot occur until all
    /// holders of VMO handles to the buffers have closed those VMO handles.
    /// Therefore clients should take care not to become blocked forever waiting
    /// for ZX_EVENTPAIR_PEER_CLOSED to be signalled, especially if any of the
    /// participants using the logical buffer collection are less trusted or
    /// less reliable.
    ///
    /// The buffers_remaining parameter allows waiting for all but
    /// buffers_remaining buffers to be fully deallocated.  This can be useful
    /// in situations where a known number of buffers are intentionally not
    /// closed so that the data can continue to be used, such as for keeping the
    /// last available video picture displayed in the UI even if the video
    /// stream was using protected output buffers.  It's outside the scope of
    /// the BufferCollection interface (at least for now) to determine how many
    /// buffers may be held without closing, but it'll typically be in the range
    /// 0-2.
    ///
    /// This mechanism is meant to be compatible with other protocols providing
    /// a similar AttachLifetimeTracking() mechanism, in that duplicates of the
    /// same event can be sent to more than one AttachLifetimeTracking(), and
    /// the ZX_EVENTPAIR_PEER_CLOSED will be signalled when all the lifetime
    /// over conditions are met (all holders of duplicates have closed their
    /// handle(s)).
    ///
    /// There is no way to cancel an attach.  Closing the client end of the
    /// eventpair doesn't subtract from the number of pending attach(es).
    ///
    /// Closing the client's end doesn't result in any action by the server.
    /// If the server listens to events from the client end at all, it is for
    /// debug logging only.
    ///
    /// The server intentionally doesn't "trust" any bits signalled by the
    /// client.  This mechanism intentionally uses only ZX_EVENTPAIR_PEER_CLOSED
    /// which can't be triggered early, and is only triggered when all handles
    /// to server_end are closed.  No meaning is associated with any of the
    /// other signal bits, and clients should functionally ignore any other
    /// signal bits on either end of the eventpair or its peer.
    ///
    /// The server_end may lack ZX_RIGHT_SIGNAL or ZX_RIGHT_SIGNAL_PEER, but
    /// must have ZX_RIGHT_DUPLICATE (and must have ZX_RIGHT_TRANSFER to
    /// transfer without causing CodecFactory channel failure).
    pub fn r#attach_lifetime_tracking(
        &self,
        mut server_end: fdomain_client::EventPair,
        mut buffers_remaining: u32,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#attach_lifetime_tracking(
            self,
            server_end,
            buffers_remaining,
        )
    }
}

impl BufferCollectionProxyInterface for BufferCollectionProxy {
    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,
                0x4577e238ae26291,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4577e238ae26291,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetNameRequest>(
            (priority, name),
            0x77a41bb6217e2443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugClientInfoRequest>(
            (name, id),
            0x7275759070eb5ee2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugTimeoutLogDeadlineRequest>(
            (deadline,),
            0x46d38f4772638867,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetNodeRefResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x467b7c75c35c3b84,
            >(_buf?)?;
            Ok(_response.node_ref)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Event>(
            (),
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeIsAlternateForResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x33a2a7aff2776c07,
            >(_buf?)?;
            Ok(_response.map(|x| x.is_alternate))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            (node_ref,),
            0x33a2a7aff2776c07,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_constraints(
        &self,
        mut has_constraints: bool,
        mut constraints: &BufferCollectionConstraints,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionSetConstraintsRequest>(
            (has_constraints, constraints),
            0x4d9c3406c213227b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WaitForBuffersAllocatedResponseFut = fidl::client::QueryResponseFut<
        (i32, BufferCollectionInfo2),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#wait_for_buffers_allocated(&self) -> Self::WaitForBuffersAllocatedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, BufferCollectionInfo2), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BufferCollectionWaitForBuffersAllocatedResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x714667ea2a29a3a2,
            >(_buf?)?;
            Ok((_response.status, _response.buffer_collection_info))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, BufferCollectionInfo2)>(
                (),
                0x714667ea2a29a3a2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CheckBuffersAllocatedResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#check_buffers_allocated(&self) -> Self::CheckBuffersAllocatedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BufferCollectionCheckBuffersAllocatedResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x245bb81f79189e9,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x245bb81f79189e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#attach_token(
        &self,
        mut rights_attenuation_mask: u32,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionAttachTokenRequest>(
            (rights_attenuation_mask, token_request),
            0x6f5adcca4ac7443e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#attach_lifetime_tracking(
        &self,
        mut server_end: fdomain_client::EventPair,
        mut buffers_remaining: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionAttachLifetimeTrackingRequest>(
            (server_end, buffers_remaining),
            0x170d0f1d89d50989,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for BufferCollectionRequestStream {
    type Protocol = BufferCollectionMarker;
    type ControlHandle = BufferCollectionControlHandle;

    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 {
        BufferCollectionControlHandle { 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 BufferCollectionRequestStream {
    type Item = Result<BufferCollectionRequest, 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 BufferCollectionRequestStream 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 {
                0x4577e238ae26291 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::Sync {
                        responder: BufferCollectionSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5b1d7a4f5681fca7 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::Close {
                        control_handle,
                    })
                }
                0x77a41bb6217e2443 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetNameRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetNameRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetName {priority: req.priority,
name: req.name,

                        control_handle,
                    })
                }
                0x7275759070eb5ee2 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugClientInfoRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugClientInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetDebugClientInfo {name: req.name,
id: req.id,

                        control_handle,
                    })
                }
                0x46d38f4772638867 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugTimeoutLogDeadlineRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugTimeoutLogDeadlineRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetDebugTimeoutLogDeadline {deadline: req.deadline,

                        control_handle,
                    })
                }
                0x6bfbe2cf1701d288 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetVerboseLogging {
                        control_handle,
                    })
                }
                0x467b7c75c35c3b84 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::GetNodeRef {
                        responder: BufferCollectionGetNodeRefResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x33a2a7aff2776c07 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NodeIsAlternateForRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeIsAlternateForRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::IsAlternateFor {node_ref: req.node_ref,

                        responder: BufferCollectionIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4d9c3406c213227b => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionSetConstraintsRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionSetConstraintsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetConstraints {has_constraints: req.has_constraints,
constraints: req.constraints,

                        control_handle,
                    })
                }
                0x714667ea2a29a3a2 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::WaitForBuffersAllocated {
                        responder: BufferCollectionWaitForBuffersAllocatedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x245bb81f79189e9 => {
                    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 = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::CheckBuffersAllocated {
                        responder: BufferCollectionCheckBuffersAllocatedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6f5adcca4ac7443e => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionAttachTokenRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionAttachTokenRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::AttachToken {rights_attenuation_mask: req.rights_attenuation_mask,
token_request: req.token_request,

                        control_handle,
                    })
                }
                0x170d0f1d89d50989 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionAttachLifetimeTrackingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionAttachLifetimeTrackingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::AttachLifetimeTracking {server_end: req.server_end,
buffers_remaining: req.buffers_remaining,

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

/// BufferCollection is a connection directly from a participant to sysmem re.
/// a logical BufferCollection; typically the logical BufferCollection is shared
/// with other participants.  In other words, an instance of the BufferCollection
/// interface is a view of a "logical buffer collection".
///
/// This connection exists to facilitate async indication of when the logical
/// BufferCollection has been populated with buffers.
///
/// Also, the channel's closure by the server is an indication to the client
/// that the client should close all VMO handles that were obtained from the
/// BufferCollection ASAP.
///
/// Also, this interface may in future allow specifying constraints in other
/// ways, and may allow for back-and-forth negotiation of constraints to some
/// degree.
///
/// This interface may in future allow for more than 64 VMO handles per
/// BufferCollection, but currently the limit is 64.
///
/// This interface may in future allow for allocating/deallocating single
/// buffers.
///
/// Some initiators may wait a short duration until all old logical
/// BufferCollection VMO handles have closed (or until the short duration times
/// out) before allocating a new BufferCollection, to help control physical
/// memory fragmentation and avoid overlap of buffer allocation lifetimes for
/// the old and new collections. Collections can be large enough that it's worth
/// avoiding allocation overlap (in time).
#[derive(Debug)]
pub enum BufferCollectionRequest {
    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    Sync { responder: BufferCollectionSyncResponder },
    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    Close { control_handle: BufferCollectionControlHandle },
    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    SetName { priority: u32, name: String, control_handle: BufferCollectionControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    SetDebugClientInfo { name: String, id: u64, control_handle: BufferCollectionControlHandle },
    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    SetDebugTimeoutLogDeadline { deadline: i64, control_handle: BufferCollectionControlHandle },
    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    SetVerboseLogging { control_handle: BufferCollectionControlHandle },
    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    GetNodeRef { responder: BufferCollectionGetNodeRefResponder },
    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    IsAlternateFor {
        node_ref: fdomain_client::Event,
        responder: BufferCollectionIsAlternateForResponder,
    },
    /// Provide BufferCollectionConstraints to the logical BufferCollection.
    ///
    /// A participant may only call SetConstraints() once.
    ///
    /// Sometimes the initiator is a participant only in the sense of wanting to
    /// keep an eye on success/failure to populate with buffers, and zx.Status
    /// on failure.  In that case, `has_constraints` can be false, and
    /// `constraints` will be ignored.
    ///
    /// VMO handles will not be provided to the client that sends null
    /// constraints - that can be intentional for an initiator that doesn't need
    /// VMO handles.  Not having VMO handles doesn't prevent the initator from
    /// adjusting which portion of a buffer is considered valid and similar, but
    /// the initiator can't hold a VMO handle open to prevent the logical
    /// BufferCollection from cleaning up if the logical BufferCollection needs
    /// to go away regardless of the initiator's degree of involvement for
    /// whatever reason.
    ///
    /// For population of buffers to be attempted, all holders of a
    /// BufferCollection client channel need to call SetConstraints() before
    /// sysmem will attempt to allocate buffers.
    ///
    /// `has_constraints` if false, the constraints are effectively null, and
    /// `constraints` are ignored.  The sender of null constraints won't get any
    /// VMO handles in BufferCollectionInfo, but can still find out how many
    /// buffers were allocated and can still refer to buffers by their
    /// buffer_index.
    ///
    /// `constraints` are constraints on the buffer collection.
    SetConstraints {
        has_constraints: bool,
        constraints: BufferCollectionConstraints,
        control_handle: BufferCollectionControlHandle,
    },
    /// This request completes when buffers have been allocated, responds with
    /// some failure detail if allocation has been attempted but failed.
    ///
    /// The following must occur before buffers will be allocated:
    ///   * All BufferCollectionToken(s) of the logical BufferCollectionToken
    ///     must be turned in via BindSharedCollection().
    ///   * All BufferCollection(s) of the logical BufferCollection must have
    ///     had SetConstraints() sent to them.
    ///
    /// Returns `ZX_OK` if successful.
    /// Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
    /// fulfilled due to resource exhaustion.
    /// Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
    /// obtain the buffers it requested.
    /// Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
    /// Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
    /// satisfied, perhaps due to hardware limitations.
    ///
    /// `buffer_collection_info` has the VMO handles and other related info.
    WaitForBuffersAllocated { responder: BufferCollectionWaitForBuffersAllocatedResponder },
    /// This returns the same result code as WaitForBuffersAllocated if the
    /// buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
    /// if WaitForBuffersAllocated would block.
    CheckBuffersAllocated { responder: BufferCollectionCheckBuffersAllocatedResponder },
    /// Create a new token, for trying to add a new participant to an existing
    /// collection, if the existing collection's buffer counts, constraints,
    /// and participants allow.
    ///
    /// This can be useful in replacing a failed participant, and/or in
    /// adding/re-adding a participant after buffers have already been
    /// allocated.
    ///
    /// Failure of an attached token / collection does not propagate to the
    /// parent of the attached token.  Failure does propagate from a normal
    /// child of a dispensable token to the dispensable token.  Failure
    /// of a child is blocked from reaching its parent if the child is attached,
    /// or if the child is dispensable and the failure occurred after logical
    /// allocation.
    ///
    /// An initiator may in some scenarios choose to initially use a dispensable
    /// token for a given instance of a participant, and then later if the first
    /// instance of that participant fails, a new second instance of that
    /// participant my be given a token created with AttachToken().
    ///
    /// From the point of view of the client end of the BufferCollectionToken
    /// channel, the token acts like any other token.  The client can
    /// Duplicate() the token as needed, and can send the token to a different
    /// process.  The token should be converted to a BufferCollection channel
    /// as normal by calling BindSharedCollection().  SetConstraints() should
    /// be called on that BufferCollection channel.
    ///
    /// A success result from WaitForBuffersAllocated() means the new
    /// participant's constraints were satisfiable using the already-existing
    /// buffer collection, the already-established BufferCollectionInfo
    /// including image format constraints, and the already-existing other
    /// participants and their buffer counts.  A failure result means the new
    /// participant's constraints cannot be satisfied using the existing
    /// buffer collection and its already-logically-allocated participants.
    /// Creating a new collection instead may allow all participant's
    /// constraints to be satisfied, assuming SetDispensable() is used in place
    /// of AttachToken(), or a normal token is used.
    ///
    /// A token created with AttachToken() performs constraints aggregation with
    /// all constraints currently in effect on the buffer collection, plus the
    /// attached token under consideration plus child tokens under the attached
    /// token which are not themselves an attached token or under such a token.
    ///
    /// Allocation of buffer_count to min_buffer_count_for_camping etc is
    /// first-come first-served, but a child can't logically allocate before
    /// all its parents have sent SetConstraints().
    ///
    /// See also SetDispensable(), which in contrast to AttachToken(), has the
    /// created token + children participate in constraints aggregation along
    /// with its parent.
    ///
    /// The newly created token needs to be Sync()ed to sysmem before the new
    /// token can be passed to BindSharedCollection().  The Sync() of the new
    /// token can be accomplished with BufferCollection.Sync() on this
    /// BufferCollection.  Alternately BufferCollectionToken.Sync() on the new
    /// token also works.  A BufferCollectionToken.Sync() can be started after
    /// any BufferCollectionToken.Duplicate() messages have been sent via the
    /// newly created token, to also sync those additional tokens to sysmem
    /// using a single round-trip.
    ///
    /// These values for rights_attenuation_mask result in no attenuation (note
    /// that 0 is not on this list; 0 will output an ERROR to the system log
    /// to help diagnose the bug in client code):
    ///   * ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   * 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    AttachToken {
        rights_attenuation_mask: u32,
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        control_handle: BufferCollectionControlHandle,
    },
    /// AttachLifetimeTracking:
    ///
    /// AttachLifetimeTracking() is intended to allow a client to wait until an
    /// old logical buffer collection is fully or mostly deallocated before
    /// attempting allocation of a new logical buffer collection.
    ///
    /// Attach an eventpair endpoint to the logical buffer collection, so that
    /// the server_end will be closed when the number of buffers allocated
    /// drops to 'buffers_remaining'.  The server_end won't close until after
    /// logical allocation has completed.
    ///
    /// If logical allocation fails, such as for an attached sub-tree (using
    /// AttachToken()), the server_end will close during that failure regardless
    /// of the number of buffers potenitally allocated in the overall logical
    /// buffer collection.
    ///
    /// The lifetime signalled by this event includes asynchronous cleanup of
    /// allocated buffers, and this asynchronous cleanup cannot occur until all
    /// holders of VMO handles to the buffers have closed those VMO handles.
    /// Therefore clients should take care not to become blocked forever waiting
    /// for ZX_EVENTPAIR_PEER_CLOSED to be signalled, especially if any of the
    /// participants using the logical buffer collection are less trusted or
    /// less reliable.
    ///
    /// The buffers_remaining parameter allows waiting for all but
    /// buffers_remaining buffers to be fully deallocated.  This can be useful
    /// in situations where a known number of buffers are intentionally not
    /// closed so that the data can continue to be used, such as for keeping the
    /// last available video picture displayed in the UI even if the video
    /// stream was using protected output buffers.  It's outside the scope of
    /// the BufferCollection interface (at least for now) to determine how many
    /// buffers may be held without closing, but it'll typically be in the range
    /// 0-2.
    ///
    /// This mechanism is meant to be compatible with other protocols providing
    /// a similar AttachLifetimeTracking() mechanism, in that duplicates of the
    /// same event can be sent to more than one AttachLifetimeTracking(), and
    /// the ZX_EVENTPAIR_PEER_CLOSED will be signalled when all the lifetime
    /// over conditions are met (all holders of duplicates have closed their
    /// handle(s)).
    ///
    /// There is no way to cancel an attach.  Closing the client end of the
    /// eventpair doesn't subtract from the number of pending attach(es).
    ///
    /// Closing the client's end doesn't result in any action by the server.
    /// If the server listens to events from the client end at all, it is for
    /// debug logging only.
    ///
    /// The server intentionally doesn't "trust" any bits signalled by the
    /// client.  This mechanism intentionally uses only ZX_EVENTPAIR_PEER_CLOSED
    /// which can't be triggered early, and is only triggered when all handles
    /// to server_end are closed.  No meaning is associated with any of the
    /// other signal bits, and clients should functionally ignore any other
    /// signal bits on either end of the eventpair or its peer.
    ///
    /// The server_end may lack ZX_RIGHT_SIGNAL or ZX_RIGHT_SIGNAL_PEER, but
    /// must have ZX_RIGHT_DUPLICATE (and must have ZX_RIGHT_TRANSFER to
    /// transfer without causing CodecFactory channel failure).
    AttachLifetimeTracking {
        server_end: fdomain_client::EventPair,
        buffers_remaining: u32,
        control_handle: BufferCollectionControlHandle,
    },
}

impl BufferCollectionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(BufferCollectionSyncResponder)> {
        if let BufferCollectionRequest::Sync { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_name(self) -> Option<(u32, String, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetName { priority, name, control_handle } = self {
            Some((priority, name, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_client_info(
        self,
    ) -> Option<(String, u64, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetDebugClientInfo { name, id, control_handle } = self {
            Some((name, id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(i64, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetDebugTimeoutLogDeadline { deadline, control_handle } =
            self
        {
            Some((deadline, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_verbose_logging(self) -> Option<(BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetVerboseLogging { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_node_ref(self) -> Option<(BufferCollectionGetNodeRefResponder)> {
        if let BufferCollectionRequest::GetNodeRef { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_alternate_for(
        self,
    ) -> Option<(fdomain_client::Event, BufferCollectionIsAlternateForResponder)> {
        if let BufferCollectionRequest::IsAlternateFor { node_ref, responder } = self {
            Some((node_ref, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_constraints(
        self,
    ) -> Option<(bool, BufferCollectionConstraints, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetConstraints {
            has_constraints,
            constraints,
            control_handle,
        } = self
        {
            Some((has_constraints, constraints, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_buffers_allocated(
        self,
    ) -> Option<(BufferCollectionWaitForBuffersAllocatedResponder)> {
        if let BufferCollectionRequest::WaitForBuffersAllocated { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_check_buffers_allocated(
        self,
    ) -> Option<(BufferCollectionCheckBuffersAllocatedResponder)> {
        if let BufferCollectionRequest::CheckBuffersAllocated { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_token(
        self,
    ) -> Option<(
        u32,
        fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        BufferCollectionControlHandle,
    )> {
        if let BufferCollectionRequest::AttachToken {
            rights_attenuation_mask,
            token_request,
            control_handle,
        } = self
        {
            Some((rights_attenuation_mask, token_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_lifetime_tracking(
        self,
    ) -> Option<(fdomain_client::EventPair, u32, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::AttachLifetimeTracking {
            server_end,
            buffers_remaining,
            control_handle,
        } = self
        {
            Some((server_end, buffers_remaining, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BufferCollectionRequest::Sync { .. } => "sync",
            BufferCollectionRequest::Close { .. } => "close",
            BufferCollectionRequest::SetName { .. } => "set_name",
            BufferCollectionRequest::SetDebugClientInfo { .. } => "set_debug_client_info",
            BufferCollectionRequest::SetDebugTimeoutLogDeadline { .. } => {
                "set_debug_timeout_log_deadline"
            }
            BufferCollectionRequest::SetVerboseLogging { .. } => "set_verbose_logging",
            BufferCollectionRequest::GetNodeRef { .. } => "get_node_ref",
            BufferCollectionRequest::IsAlternateFor { .. } => "is_alternate_for",
            BufferCollectionRequest::SetConstraints { .. } => "set_constraints",
            BufferCollectionRequest::WaitForBuffersAllocated { .. } => "wait_for_buffers_allocated",
            BufferCollectionRequest::CheckBuffersAllocated { .. } => "check_buffers_allocated",
            BufferCollectionRequest::AttachToken { .. } => "attach_token",
            BufferCollectionRequest::AttachLifetimeTracking { .. } => "attach_lifetime_tracking",
        }
    }
}

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

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

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

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

impl BufferCollectionControlHandle {}

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

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

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

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

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

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

    fn send_raw(&self, mut node_ref: fdomain_client::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeGetNodeRefResponse>(
            (node_ref,),
            self.tx_id,
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>>(
                result.map(|is_alternate| (is_alternate,)),
                self.tx_id,
                0x33a2a7aff2776c07,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut status: i32,
        mut buffer_collection_info: BufferCollectionInfo2,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BufferCollectionWaitForBuffersAllocatedResponse>(
            (status, &mut buffer_collection_info),
            self.tx_id,
            0x714667ea2a29a3a2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for BufferCollectionTokenMarker {
    type Proxy = BufferCollectionTokenProxy;
    type RequestStream = BufferCollectionTokenRequestStream;

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

pub trait BufferCollectionTokenProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, priority: u32, name: &str) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(&self, name: &str, id: u64) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(&self, deadline: i64) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<fdomain_client::Event, fidl::Error>>
        + Send;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut;
    type IsAlternateForResponseFut: std::future::Future<Output = Result<NodeIsAlternateForResult, fidl::Error>>
        + Send;
    fn r#is_alternate_for(
        &self,
        node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut;
    type DuplicateSyncResponseFut: std::future::Future<
            Output = Result<
                Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
                fidl::Error,
            >,
        > + Send;
    fn r#duplicate_sync(
        &self,
        rights_attenuation_masks: &[fidl::Rights],
    ) -> Self::DuplicateSyncResponseFut;
    fn r#duplicate(
        &self,
        rights_attenuation_mask: u32,
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_dispensable(&self) -> Result<(), fidl::Error>;
    fn r#create_buffer_collection_token_group(
        &self,
        group_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
    ) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for BufferCollectionTokenProxy {
    type Protocol = BufferCollectionTokenMarker;

    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 BufferCollectionTokenProxy {
    /// Create a new Proxy for fuchsia.sysmem/BufferCollectionToken.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <BufferCollectionTokenMarker 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) -> BufferCollectionTokenEventStream {
        BufferCollectionTokenEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionTokenProxyInterface::r#sync(self)
    }

    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#close(self)
    }

    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    pub fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_name(self, priority, name)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    pub fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_debug_client_info(self, name, id)
    }

    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    pub fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_debug_timeout_log_deadline(self, deadline)
    }

    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#get_node_ref(self)
    }

    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    pub fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#is_alternate_for(self, node_ref)
    }

    /// This method can be used to add more participants prior to creating a
    /// shared BufferCollection. A new token will be returned for each entry in
    /// the `rights_attenuation_masks` array. The return value is the client
    /// ends of each new participant token.
    ///
    /// If the calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, consider using
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if DuplicateSync() never responds due to the calling
    /// token not being a real token.
    ///
    /// In contrast to Duplicate(), no Sync() (see "protocol Node") is needed
    /// after calling this method.
    ///
    /// All tokens must be turned in via BindSharedCollection() or Close() for a
    /// BufferCollection to be successfully created.
    ///
    /// In each entry of `rights_attenuation_masks`, rights bits that are zero
    /// will be absent in the buffer VMO rights obtainable via the corresponding
    /// returned token. This allows an initiator or intermediary participant to
    /// attenuate the rights available to a participant. This does not allow a
    /// participant to gain rights that the participant doesn't already have.
    /// The value ZX_RIGHT_SAME_RIGHTS can be used to specify that no
    /// attenuation should be applied.
    pub fn r#duplicate_sync(
        &self,
        mut rights_attenuation_masks: &[fidl::Rights],
    ) -> fidl::client::QueryResponseFut<
        Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#duplicate_sync(self, rights_attenuation_masks)
    }

    /// This method can be used to add a participant prior to creating a shared
    /// BufferCollection. It should only be used instead of DuplicateSync in
    /// performance sensitive cases where it would be undesireable to wait for
    /// sysmem to respond as part of each duplicate.
    ///
    /// After sending one or more Duplicate() messages, and before sending the
    /// created tokens to other participants (or to other Allocator channels),
    /// the client should send a Sync() and wait for its response.  The Sync()
    /// call can be made on the token, or on the BufferCollection obtained by
    /// passing this token to BindSharedCollection().  Either will ensure that
    /// the server knows about the tokens created via Duplicate() before the
    /// other participant sends the token to the server via separate Allocator
    /// channel.
    ///
    /// All tokens must be turned in via BindSharedCollection() or Close() for a
    /// BufferCollection to be successfully created.
    ///
    /// When a client calls BindSharedCollection() to turn in a
    /// BufferCollectionToken, the server will process all Duplicate() messages
    /// before closing down the BufferCollectionToken.  This allows the client
    /// to Duplicate() and immediately turn in the BufferCollectionToken using
    /// BindSharedCollection, then later transfer the client end of token_request
    /// to another participant - the server will notice the existence of the
    /// token_request before considering this BufferCollectionToken fully closed.
    ///
    /// `rights_attenuation_mask` rights bits that are zero in this mask will be
    /// absent in the buffer VMO rights obtainable via the client end of
    /// token_request. This allows an initiator or intermediary participant to
    /// attenuate the rights available to a participant. This does not allow a
    /// participant to gain rights that the participant doesn't already have.
    /// The value ZX_RIGHT_SAME_RIGHTS can be used to specify that no
    /// attenuation should be applied.
    ///
    /// These values for rights_attenuation_mask result in no attenuation:
    ///   * ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   * 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    ///   * 0 (deprecated - do not use 0 - an ERROR will go to the log)
    ///
    /// `token_request` is the server end of a BufferCollectionToken channel.
    /// The client end of this channel acts as another participant in creating the
    /// shared BufferCollection.
    pub fn r#duplicate(
        &self,
        mut rights_attenuation_mask: u32,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#duplicate(
            self,
            rights_attenuation_mask,
            token_request,
        )
    }

    /// A dispensable token can fail after buffers are logically allocated
    /// without causing failure of its parent (if any).
    ///
    /// The dispensable token participates in constraints aggregation along with
    /// its parent before logical buffer allocation.  If the dispensable token
    /// fails before buffers are logically allocated, the failure propagates to
    /// the dispensable token's parent.
    ///
    /// After buffers are logically allocated, failure of the dispensable token
    /// (or any child of the dispensable token) does not propagate to the
    /// dispensable token's parent.  Failure does propagate from a normal
    /// child of a dispensable token to the dispensable token.  Failure
    /// of a child is blocked from reaching its parent if the child is attached,
    /// or if the child is dispensable and the failure occurred after logical
    /// allocation.
    ///
    /// A dispensable token can be used in cases where a participant needs to
    /// provide constraints, but after buffers are allocated, the participant
    /// can fail without causing buffer collection failure from the parent's
    /// point of view.
    ///
    /// In contrast, AttachToken() can be used to create a token which does not
    /// participate in constraints aggregation with its parent, and whose
    /// failure at any time does not propagate to its parent, and whose delay
    /// providing constraints does not prevent the parent from completing its
    /// buffer allocation.
    ///
    /// An initiator may in some scenarios choose to initially use a dispensable
    /// token for a given instance of a participant, and then later if the first
    /// instance of that participant fails, a new second instance of that
    /// participant my be given a token created with AttachToken().
    ///
    /// If a client uses this message, the client should not rely on the
    /// client's own BufferCollectionToken or BufferCollection channel to close
    /// from the server end due to abrupt failure of any BufferCollectionToken
    /// or BufferCollection that the client has SetDispensable() and given out
    /// to another process.  For this reason, the client should take extra care
    /// to notice failure of that other process via other means.
    ///
    /// While it is possible (and potentially useful) to SetDispensable() on a
    /// direct child of a BufferCollectionTokenGroup, it isn't possible to later
    /// replace a failed dispensable token that was a direct child of a group
    /// with a new token using AttachToken() (since there's no AttachToken() on
    /// a group).  Instead, to enable AttachToken() replacement in this case,
    /// create an additional non-dispensable token (node) that's a direct child
    /// of the group and make the existing dispensable token a child of the
    /// additional token (node).  This way, the additional token (node) that is
    /// a direct child of the group has BufferCollection.AttachToken() which can
    /// be used to replace the failed dispensable token.
    ///
    /// SetDispensable() on an already-dispensable token is idempotent.
    pub fn r#set_dispensable(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_dispensable(self)
    }

    /// Most sysmem clients and many participants don't need to care about this
    /// message or about BufferCollectionTokenGroup(s) in general.
    ///
    /// A BufferCollectionTokenGroup is used to create a 1 of N OR among N child
    /// tokens.  The child tokens which are not selected during aggregation will
    /// fail (close), which a potential participant should notice when their
    /// BufferCollection channel client endpoint sees PEER_CLOSED, allowing the
    /// participant to clean up the speculative usage that didn't end up
    /// happening (similarly to a normal BufferCollection server end closing
    /// on failure of a logical buffer collection).
    ///
    /// See comments on protocol BufferCollectionTokenGroup.
    ///
    /// Any rights_attenuation_mask or AttachToken()/SetDispensable() to be
    /// applied to the whole group can be achieved with a token for this purpose
    /// as a direct parent of the group.
    ///
    /// group_request - the server end of a BufferCollectionTokenGroup channel
    /// to be served by sysmem.
    pub fn r#create_buffer_collection_token_group(
        &self,
        mut group_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#create_buffer_collection_token_group(
            self,
            group_request,
        )
    }
}

impl BufferCollectionTokenProxyInterface for BufferCollectionTokenProxy {
    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,
                0x4577e238ae26291,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4577e238ae26291,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetNameRequest>(
            (priority, name),
            0x77a41bb6217e2443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugClientInfoRequest>(
            (name, id),
            0x7275759070eb5ee2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugTimeoutLogDeadlineRequest>(
            (deadline,),
            0x46d38f4772638867,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetNodeRefResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x467b7c75c35c3b84,
            >(_buf?)?;
            Ok(_response.node_ref)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Event>(
            (),
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeIsAlternateForResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x33a2a7aff2776c07,
            >(_buf?)?;
            Ok(_response.map(|x| x.is_alternate))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            (node_ref,),
            0x33a2a7aff2776c07,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DuplicateSyncResponseFut = fidl::client::QueryResponseFut<
        Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#duplicate_sync(
        &self,
        mut rights_attenuation_masks: &[fidl::Rights],
    ) -> Self::DuplicateSyncResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                BufferCollectionTokenDuplicateSyncResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x49ed7ab7cc19f18,
            >(_buf?)?;
            Ok(_response.tokens)
        }
        self.client.send_query_and_decode::<
            BufferCollectionTokenDuplicateSyncRequest,
            Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        >(
            (rights_attenuation_masks,),
            0x49ed7ab7cc19f18,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#duplicate(
        &self,
        mut rights_attenuation_mask: u32,
        mut token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionTokenDuplicateRequest>(
            (rights_attenuation_mask, token_request),
            0x2f9f81bdde4b7292,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#create_buffer_collection_token_group(
        &self,
        mut group_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionTokenCreateBufferCollectionTokenGroupRequest>(
            (group_request,),
            0x2f6243e05f22b9a7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for BufferCollectionTokenRequestStream {
    type Protocol = BufferCollectionTokenMarker;
    type ControlHandle = BufferCollectionTokenControlHandle;

    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 {
        BufferCollectionTokenControlHandle { 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 BufferCollectionTokenRequestStream {
    type Item = Result<BufferCollectionTokenRequest, 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 BufferCollectionTokenRequestStream 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 {
                0x4577e238ae26291 => {
                    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 = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::Sync {
                        responder: BufferCollectionTokenSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5b1d7a4f5681fca7 => {
                    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 = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::Close {
                        control_handle,
                    })
                }
                0x77a41bb6217e2443 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetNameRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetNameRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetName {priority: req.priority,
name: req.name,

                        control_handle,
                    })
                }
                0x7275759070eb5ee2 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugClientInfoRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugClientInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetDebugClientInfo {name: req.name,
id: req.id,

                        control_handle,
                    })
                }
                0x46d38f4772638867 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugTimeoutLogDeadlineRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugTimeoutLogDeadlineRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetDebugTimeoutLogDeadline {deadline: req.deadline,

                        control_handle,
                    })
                }
                0x6bfbe2cf1701d288 => {
                    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 = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetVerboseLogging {
                        control_handle,
                    })
                }
                0x467b7c75c35c3b84 => {
                    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 = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::GetNodeRef {
                        responder: BufferCollectionTokenGetNodeRefResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x33a2a7aff2776c07 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NodeIsAlternateForRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeIsAlternateForRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::IsAlternateFor {node_ref: req.node_ref,

                        responder: BufferCollectionTokenIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x49ed7ab7cc19f18 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionTokenDuplicateSyncRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionTokenDuplicateSyncRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::DuplicateSync {rights_attenuation_masks: req.rights_attenuation_masks,

                        responder: BufferCollectionTokenDuplicateSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2f9f81bdde4b7292 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionTokenDuplicateRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionTokenDuplicateRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::Duplicate {rights_attenuation_mask: req.rights_attenuation_mask,
token_request: req.token_request,

                        control_handle,
                    })
                }
                0x76e4ec34fc2cf5b3 => {
                    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 = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetDispensable {
                        control_handle,
                    })
                }
                0x2f6243e05f22b9a7 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionTokenCreateBufferCollectionTokenGroupRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionTokenCreateBufferCollectionTokenGroupRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::CreateBufferCollectionTokenGroup {group_request: req.group_request,

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

/// A BufferCollectionToken is not a BufferCollection, but rather a way to
/// identify a potential shared BufferCollection prior to the BufferCollection
/// being allocated.
///
/// We use a channel for the BufferCollectionToken instead of a single eventpair
/// (pair) because this way we can detect error conditions like a participant
/// dying mid-create.
///
/// The fuchsia.sysmem.BufferCollectionToken type is not yet deprecated due to
/// its use in some other protocols (for now), but all the internals of
/// fuchsia.sysmem.BufferCollectionToken are deprecated. Token channels serve
/// both fuchsia.sysmem.BufferCollectionToken and
/// fuchsia.sysmem2.BufferCollectionToken.
///
/// This protocol will be deprecated once other protocols have switched their
/// token fields to fuchsia.sysmem2.BufferCollectionToken.
#[derive(Debug)]
pub enum BufferCollectionTokenRequest {
    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    Sync { responder: BufferCollectionTokenSyncResponder },
    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    Close { control_handle: BufferCollectionTokenControlHandle },
    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    SetName { priority: u32, name: String, control_handle: BufferCollectionTokenControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    SetDebugClientInfo { name: String, id: u64, control_handle: BufferCollectionTokenControlHandle },
    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    SetDebugTimeoutLogDeadline { deadline: i64, control_handle: BufferCollectionTokenControlHandle },
    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    SetVerboseLogging { control_handle: BufferCollectionTokenControlHandle },
    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    GetNodeRef { responder: BufferCollectionTokenGetNodeRefResponder },
    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    IsAlternateFor {
        node_ref: fdomain_client::Event,
        responder: BufferCollectionTokenIsAlternateForResponder,
    },
    /// This method can be used to add more participants prior to creating a
    /// shared BufferCollection. A new token will be returned for each entry in
    /// the `rights_attenuation_masks` array. The return value is the client
    /// ends of each new participant token.
    ///
    /// If the calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, consider using
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if DuplicateSync() never responds due to the calling
    /// token not being a real token.
    ///
    /// In contrast to Duplicate(), no Sync() (see "protocol Node") is needed
    /// after calling this method.
    ///
    /// All tokens must be turned in via BindSharedCollection() or Close() for a
    /// BufferCollection to be successfully created.
    ///
    /// In each entry of `rights_attenuation_masks`, rights bits that are zero
    /// will be absent in the buffer VMO rights obtainable via the corresponding
    /// returned token. This allows an initiator or intermediary participant to
    /// attenuate the rights available to a participant. This does not allow a
    /// participant to gain rights that the participant doesn't already have.
    /// The value ZX_RIGHT_SAME_RIGHTS can be used to specify that no
    /// attenuation should be applied.
    DuplicateSync {
        rights_attenuation_masks: Vec<fidl::Rights>,
        responder: BufferCollectionTokenDuplicateSyncResponder,
    },
    /// This method can be used to add a participant prior to creating a shared
    /// BufferCollection. It should only be used instead of DuplicateSync in
    /// performance sensitive cases where it would be undesireable to wait for
    /// sysmem to respond as part of each duplicate.
    ///
    /// After sending one or more Duplicate() messages, and before sending the
    /// created tokens to other participants (or to other Allocator channels),
    /// the client should send a Sync() and wait for its response.  The Sync()
    /// call can be made on the token, or on the BufferCollection obtained by
    /// passing this token to BindSharedCollection().  Either will ensure that
    /// the server knows about the tokens created via Duplicate() before the
    /// other participant sends the token to the server via separate Allocator
    /// channel.
    ///
    /// All tokens must be turned in via BindSharedCollection() or Close() for a
    /// BufferCollection to be successfully created.
    ///
    /// When a client calls BindSharedCollection() to turn in a
    /// BufferCollectionToken, the server will process all Duplicate() messages
    /// before closing down the BufferCollectionToken.  This allows the client
    /// to Duplicate() and immediately turn in the BufferCollectionToken using
    /// BindSharedCollection, then later transfer the client end of token_request
    /// to another participant - the server will notice the existence of the
    /// token_request before considering this BufferCollectionToken fully closed.
    ///
    /// `rights_attenuation_mask` rights bits that are zero in this mask will be
    /// absent in the buffer VMO rights obtainable via the client end of
    /// token_request. This allows an initiator or intermediary participant to
    /// attenuate the rights available to a participant. This does not allow a
    /// participant to gain rights that the participant doesn't already have.
    /// The value ZX_RIGHT_SAME_RIGHTS can be used to specify that no
    /// attenuation should be applied.
    ///
    /// These values for rights_attenuation_mask result in no attenuation:
    ///   * ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   * 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    ///   * 0 (deprecated - do not use 0 - an ERROR will go to the log)
    ///
    /// `token_request` is the server end of a BufferCollectionToken channel.
    /// The client end of this channel acts as another participant in creating the
    /// shared BufferCollection.
    Duplicate {
        rights_attenuation_mask: u32,
        token_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// A dispensable token can fail after buffers are logically allocated
    /// without causing failure of its parent (if any).
    ///
    /// The dispensable token participates in constraints aggregation along with
    /// its parent before logical buffer allocation.  If the dispensable token
    /// fails before buffers are logically allocated, the failure propagates to
    /// the dispensable token's parent.
    ///
    /// After buffers are logically allocated, failure of the dispensable token
    /// (or any child of the dispensable token) does not propagate to the
    /// dispensable token's parent.  Failure does propagate from a normal
    /// child of a dispensable token to the dispensable token.  Failure
    /// of a child is blocked from reaching its parent if the child is attached,
    /// or if the child is dispensable and the failure occurred after logical
    /// allocation.
    ///
    /// A dispensable token can be used in cases where a participant needs to
    /// provide constraints, but after buffers are allocated, the participant
    /// can fail without causing buffer collection failure from the parent's
    /// point of view.
    ///
    /// In contrast, AttachToken() can be used to create a token which does not
    /// participate in constraints aggregation with its parent, and whose
    /// failure at any time does not propagate to its parent, and whose delay
    /// providing constraints does not prevent the parent from completing its
    /// buffer allocation.
    ///
    /// An initiator may in some scenarios choose to initially use a dispensable
    /// token for a given instance of a participant, and then later if the first
    /// instance of that participant fails, a new second instance of that
    /// participant my be given a token created with AttachToken().
    ///
    /// If a client uses this message, the client should not rely on the
    /// client's own BufferCollectionToken or BufferCollection channel to close
    /// from the server end due to abrupt failure of any BufferCollectionToken
    /// or BufferCollection that the client has SetDispensable() and given out
    /// to another process.  For this reason, the client should take extra care
    /// to notice failure of that other process via other means.
    ///
    /// While it is possible (and potentially useful) to SetDispensable() on a
    /// direct child of a BufferCollectionTokenGroup, it isn't possible to later
    /// replace a failed dispensable token that was a direct child of a group
    /// with a new token using AttachToken() (since there's no AttachToken() on
    /// a group).  Instead, to enable AttachToken() replacement in this case,
    /// create an additional non-dispensable token (node) that's a direct child
    /// of the group and make the existing dispensable token a child of the
    /// additional token (node).  This way, the additional token (node) that is
    /// a direct child of the group has BufferCollection.AttachToken() which can
    /// be used to replace the failed dispensable token.
    ///
    /// SetDispensable() on an already-dispensable token is idempotent.
    SetDispensable { control_handle: BufferCollectionTokenControlHandle },
    /// Most sysmem clients and many participants don't need to care about this
    /// message or about BufferCollectionTokenGroup(s) in general.
    ///
    /// A BufferCollectionTokenGroup is used to create a 1 of N OR among N child
    /// tokens.  The child tokens which are not selected during aggregation will
    /// fail (close), which a potential participant should notice when their
    /// BufferCollection channel client endpoint sees PEER_CLOSED, allowing the
    /// participant to clean up the speculative usage that didn't end up
    /// happening (similarly to a normal BufferCollection server end closing
    /// on failure of a logical buffer collection).
    ///
    /// See comments on protocol BufferCollectionTokenGroup.
    ///
    /// Any rights_attenuation_mask or AttachToken()/SetDispensable() to be
    /// applied to the whole group can be achieved with a token for this purpose
    /// as a direct parent of the group.
    ///
    /// group_request - the server end of a BufferCollectionTokenGroup channel
    /// to be served by sysmem.
    CreateBufferCollectionTokenGroup {
        group_request: fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
        control_handle: BufferCollectionTokenControlHandle,
    },
}

impl BufferCollectionTokenRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(BufferCollectionTokenSyncResponder)> {
        if let BufferCollectionTokenRequest::Sync { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_name(self) -> Option<(u32, String, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetName { priority, name, control_handle } = self {
            Some((priority, name, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_client_info(
        self,
    ) -> Option<(String, u64, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetDebugClientInfo { name, id, control_handle } = self
        {
            Some((name, id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(i64, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetDebugTimeoutLogDeadline {
            deadline,
            control_handle,
        } = self
        {
            Some((deadline, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_verbose_logging(self) -> Option<(BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetVerboseLogging { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_node_ref(self) -> Option<(BufferCollectionTokenGetNodeRefResponder)> {
        if let BufferCollectionTokenRequest::GetNodeRef { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_alternate_for(
        self,
    ) -> Option<(fdomain_client::Event, BufferCollectionTokenIsAlternateForResponder)> {
        if let BufferCollectionTokenRequest::IsAlternateFor { node_ref, responder } = self {
            Some((node_ref, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_duplicate_sync(
        self,
    ) -> Option<(Vec<fidl::Rights>, BufferCollectionTokenDuplicateSyncResponder)> {
        if let BufferCollectionTokenRequest::DuplicateSync { rights_attenuation_masks, responder } =
            self
        {
            Some((rights_attenuation_masks, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_duplicate(
        self,
    ) -> Option<(
        u32,
        fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
        BufferCollectionTokenControlHandle,
    )> {
        if let BufferCollectionTokenRequest::Duplicate {
            rights_attenuation_mask,
            token_request,
            control_handle,
        } = self
        {
            Some((rights_attenuation_mask, token_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_dispensable(self) -> Option<(BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetDispensable { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_buffer_collection_token_group(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
        BufferCollectionTokenControlHandle,
    )> {
        if let BufferCollectionTokenRequest::CreateBufferCollectionTokenGroup {
            group_request,
            control_handle,
        } = self
        {
            Some((group_request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BufferCollectionTokenRequest::Sync { .. } => "sync",
            BufferCollectionTokenRequest::Close { .. } => "close",
            BufferCollectionTokenRequest::SetName { .. } => "set_name",
            BufferCollectionTokenRequest::SetDebugClientInfo { .. } => "set_debug_client_info",
            BufferCollectionTokenRequest::SetDebugTimeoutLogDeadline { .. } => {
                "set_debug_timeout_log_deadline"
            }
            BufferCollectionTokenRequest::SetVerboseLogging { .. } => "set_verbose_logging",
            BufferCollectionTokenRequest::GetNodeRef { .. } => "get_node_ref",
            BufferCollectionTokenRequest::IsAlternateFor { .. } => "is_alternate_for",
            BufferCollectionTokenRequest::DuplicateSync { .. } => "duplicate_sync",
            BufferCollectionTokenRequest::Duplicate { .. } => "duplicate",
            BufferCollectionTokenRequest::SetDispensable { .. } => "set_dispensable",
            BufferCollectionTokenRequest::CreateBufferCollectionTokenGroup { .. } => {
                "create_buffer_collection_token_group"
            }
        }
    }
}

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

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

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

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

impl BufferCollectionTokenControlHandle {}

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

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

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

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

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

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

    fn send_raw(&self, mut node_ref: fdomain_client::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeGetNodeRefResponse>(
            (node_ref,),
            self.tx_id,
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>>(
                result.map(|is_alternate| (is_alternate,)),
                self.tx_id,
                0x33a2a7aff2776c07,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut tokens: Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BufferCollectionTokenDuplicateSyncResponse>(
            (tokens.as_mut(),),
            self.tx_id,
            0x49ed7ab7cc19f18,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for BufferCollectionTokenGroupMarker {
    type Proxy = BufferCollectionTokenGroupProxy;
    type RequestStream = BufferCollectionTokenGroupRequestStream;

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

pub trait BufferCollectionTokenGroupProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, priority: u32, name: &str) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(&self, name: &str, id: u64) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(&self, deadline: i64) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<fdomain_client::Event, fidl::Error>>
        + Send;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut;
    type IsAlternateForResponseFut: std::future::Future<Output = Result<NodeIsAlternateForResult, fidl::Error>>
        + Send;
    fn r#is_alternate_for(
        &self,
        node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut;
    fn r#create_child(
        &self,
        payload: BufferCollectionTokenGroupCreateChildRequest,
    ) -> Result<(), fidl::Error>;
    type CreateChildrenSyncResponseFut: std::future::Future<
            Output = Result<
                Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
                fidl::Error,
            >,
        > + Send;
    fn r#create_children_sync(
        &self,
        rights_attenuation_masks: &[fidl::Rights],
    ) -> Self::CreateChildrenSyncResponseFut;
    fn r#all_children_present(&self) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for BufferCollectionTokenGroupProxy {
    type Protocol = BufferCollectionTokenGroupMarker;

    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 BufferCollectionTokenGroupProxy {
    /// Create a new Proxy for fuchsia.sysmem/BufferCollectionTokenGroup.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <BufferCollectionTokenGroupMarker 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) -> BufferCollectionTokenGroupEventStream {
        BufferCollectionTokenGroupEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionTokenGroupProxyInterface::r#sync(self)
    }

    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#close(self)
    }

    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    pub fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_name(self, priority, name)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    pub fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_debug_client_info(self, name, id)
    }

    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    pub fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_debug_timeout_log_deadline(self, deadline)
    }

    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#get_node_ref(self)
    }

    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    pub fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#is_alternate_for(self, node_ref)
    }

    /// Create a child token.  Before passing the client end of this token to
    /// BindSharedCollection(), completion of Sync() after CreateChild() is
    /// required.  Or the client can use CreateChildrenSync() which essentially
    /// includes the Sync().
    ///
    /// token_request - the server end of the new token channel.
    ///
    /// rights_attenuation_mask - If ZX_RIGHT_SAME_RIGHTS, the created token
    /// allows the holder to get the same rights to buffers as the parent token
    /// (of the group) had.
    pub fn r#create_child(
        &self,
        mut payload: BufferCollectionTokenGroupCreateChildRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#create_child(self, payload)
    }

    /// Create 1 or more child tokens at once, synchronously.  In contrast to
    /// CreateChild(), no Sync() completion is required before passing the
    /// client end of a returned token to BindSharedCollection().
    ///
    /// The size of the rights_attentuation_mask determines the number of
    /// created child tokens.
    ///
    /// The lower-index child tokens are higher priority (attempted sooner) than
    /// higher-index child tokens.
    ///
    /// As per all child tokens, successful aggregation will choose exactly one
    /// child among all created children (across all children created across
    /// potentially multiple calls to CreateChild() and CreateChildrenSync()).
    ///
    /// The maximum permissible total number of children per group, and total
    /// number of nodes in an overall tree (from the root) are capped to limits
    /// which are not configurable via these protocols.
    pub fn r#create_children_sync(
        &self,
        mut rights_attenuation_masks: &[fidl::Rights],
    ) -> fidl::client::QueryResponseFut<
        Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#create_children_sync(
            self,
            rights_attenuation_masks,
        )
    }

    /// AllChildrenPresent()
    ///
    /// After creating all children, the client must call AllChildrenPresent()
    /// to inform sysmem that no more children will be created, so that sysmem
    /// can know when it's ok to start aggregating constraints.
    ///
    /// If Close() is to be sent, it should be sent _after_
    /// AllChildrenPresent(), else failure of the group and propagation of the
    /// failure to the group's parent will still be triggered.
    pub fn r#all_children_present(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#all_children_present(self)
    }
}

impl BufferCollectionTokenGroupProxyInterface for BufferCollectionTokenGroupProxy {
    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,
                0x4577e238ae26291,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4577e238ae26291,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetNameRequest>(
            (priority, name),
            0x77a41bb6217e2443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugClientInfoRequest>(
            (name, id),
            0x7275759070eb5ee2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugTimeoutLogDeadlineRequest>(
            (deadline,),
            0x46d38f4772638867,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetNodeRefResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x467b7c75c35c3b84,
            >(_buf?)?;
            Ok(_response.node_ref)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Event>(
            (),
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeIsAlternateForResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x33a2a7aff2776c07,
            >(_buf?)?;
            Ok(_response.map(|x| x.is_alternate))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            (node_ref,),
            0x33a2a7aff2776c07,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#create_child(
        &self,
        mut payload: BufferCollectionTokenGroupCreateChildRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BufferCollectionTokenGroupCreateChildRequest>(
            &mut payload,
            0x2e74f8bcbf59ee59,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CreateChildrenSyncResponseFut = fidl::client::QueryResponseFut<
        Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_children_sync(
        &self,
        mut rights_attenuation_masks: &[fidl::Rights],
    ) -> Self::CreateChildrenSyncResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                BufferCollectionTokenGroupCreateChildrenSyncResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x569dc3ca2a98f535,
            >(_buf?)?;
            Ok(_response.tokens)
        }
        self.client.send_query_and_decode::<
            BufferCollectionTokenGroupCreateChildrenSyncRequest,
            Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
        >(
            (rights_attenuation_masks,),
            0x569dc3ca2a98f535,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for BufferCollectionTokenGroupRequestStream {
    type Protocol = BufferCollectionTokenGroupMarker;
    type ControlHandle = BufferCollectionTokenGroupControlHandle;

    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 {
        BufferCollectionTokenGroupControlHandle { 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 BufferCollectionTokenGroupRequestStream {
    type Item = Result<BufferCollectionTokenGroupRequest, 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 BufferCollectionTokenGroupRequestStream 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 {
                0x4577e238ae26291 => {
                    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 = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::Sync {
                        responder: BufferCollectionTokenGroupSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5b1d7a4f5681fca7 => {
                    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 = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::Close {
                        control_handle,
                    })
                }
                0x77a41bb6217e2443 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetNameRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetNameRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::SetName {priority: req.priority,
name: req.name,

                        control_handle,
                    })
                }
                0x7275759070eb5ee2 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugClientInfoRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugClientInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::SetDebugClientInfo {name: req.name,
id: req.id,

                        control_handle,
                    })
                }
                0x46d38f4772638867 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetDebugTimeoutLogDeadlineRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugTimeoutLogDeadlineRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::SetDebugTimeoutLogDeadline {deadline: req.deadline,

                        control_handle,
                    })
                }
                0x6bfbe2cf1701d288 => {
                    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 = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::SetVerboseLogging {
                        control_handle,
                    })
                }
                0x467b7c75c35c3b84 => {
                    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 = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::GetNodeRef {
                        responder: BufferCollectionTokenGroupGetNodeRefResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x33a2a7aff2776c07 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NodeIsAlternateForRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeIsAlternateForRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::IsAlternateFor {node_ref: req.node_ref,

                        responder: BufferCollectionTokenGroupIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2e74f8bcbf59ee59 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionTokenGroupCreateChildRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionTokenGroupCreateChildRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::CreateChild {payload: req,
                        control_handle,
                    })
                }
                0x569dc3ca2a98f535 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BufferCollectionTokenGroupCreateChildrenSyncRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BufferCollectionTokenGroupCreateChildrenSyncRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::CreateChildrenSync {rights_attenuation_masks: req.rights_attenuation_masks,

                        responder: BufferCollectionTokenGroupCreateChildrenSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1d41715f6f044b50 => {
                    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 = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::AllChildrenPresent {
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BufferCollectionTokenGroupMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// The sysmem implementation is guaranteed to be consistent with a logical /
/// conceptual model as follows:
///
/// As usual, a logical allocation considers either the root and all nodes with
/// connectivity to the root that don't transit an AttachToken(), or a sub-tree
/// rooted at an AttachToken() token and all nodes with connectivity to that
/// subtree that don't transit another AttachToken().  This is called the
/// logical allocation pruned sub-tree, or pruned sub-tree for short.
///
/// During constraints aggregation, each BufferCollectionTokenGroup will select
/// a single child token among its children.  The rest of the children will
/// appear to fail the logical allocation, while the selected child may succeed.
///
/// When more than one BufferCollectionTokenGroup exists in the overall logical
/// allocation pruned sub-tree, the relative priority between two groups is
/// equivalent to their ordering in a DFS pre-order iteration of the tree, with
/// parents higher priority than children, and left children higher priority
/// than right children.
///
/// When a particular child of a group is selected (whether provisionally during
/// a constraints aggregation attempt, or as a final selection), the
/// non-selection of other children of the group can potentially "hide" other
/// groups under those non-selected children.
///
/// Within a logical allocation, aggregation is attempted first by provisionally
/// selecting the child 0 of the highest-priority group, and child 0 of the next
/// highest-priority group that isn't hidden by the provisional selections so
/// far, etc.
///
/// If that aggregation attempt fails, aggregation will be attempted with the
/// ordinal 0 child of all the same groups except the lowest priority non-hidden
/// group which will provisionally select its ordinal 1 child (and then child 2
/// and so on).  If a new lowest-priority group is un-hidden as provisional
/// selections are updated, that newly un-hidden lowest-priority group has all
/// its children considered in order, before changing the provisional selection
/// in the former lowest-priority group.  In terms of result, this is equivalent
/// to systematic enumeration of all possible combinations of choices in a
/// counting-like order updating the lowest-priority group the most often and
/// the highest-priority group the least often.  Rather than actually attempting
/// aggregation with all the combinations, we can skip over combinations which
/// are redundant/equivalent due to hiding without any change to the result.
///
/// Attempted aggregations of enumerated non-equivalent combinations of choices
/// continue in this manner until either (a) all aggregation attempts fail in
/// which case the overall logical allocation fails, or (b) until an attempted
/// aggregation succeeds, in which case buffer allocation (if needed) is
/// attempted once.  If buffer allocation based on the first successful
/// aggregation fails, the overall logical allocation fails (there is no buffer
/// allocation retry / re-attempt).  If buffer allocation succeeds (or is not
/// needed), the logical allocation succeeds.
///
/// If this prioritization scheme cannot reasonably work for your usage of
/// sysmem, please contact sysmem folks to discuss potentially adding a way to
/// achieve what you need.
///
/// Please avoid creating a large number of BufferCollectionTokenGroup(s) per
/// logical allocation, especially with large number of children overall, and
/// especially in cases where aggregation may reasonably be expected to often
/// fail using ordinal 0 children and possibly with later children as well.  We
/// anticipate mitigating potentially high time complexity of evaluating too
/// many child combinations/selections across too many groups by simply failing
/// logical allocation beyond a certain (fairly high, but not huge) max number
/// of considered group child combinations/selections.  More advanced (and more
/// complicated) mitigation is not anticipated to be practically necessary or
/// worth the added complexity.  Please contact sysmem folks if the max limit
/// is getting hit or if you anticipate it getting hit, to discuss potential
/// options.
///
/// Prefer to use multiple ImageFormatConstraints in a single
/// BufferCollectionConstraints when feasible (when a participant just needs to
/// express the ability to work with more than a single PixelFormat, with
/// sysmem choosing which PixelFormat to use among those supported by all
/// participants).
///
/// Similar to BufferCollectionToken and BufferCollection, closure of the
/// BufferCollectionTokenGroup channel without sending Close() first will cause
/// logical buffer collection failure (or sub-tree failure if using
/// SetDispensable() or AttachToken() and the BufferCollectionTokenGroup is part
/// of a sub-tree under such a node that doesn't propagate failure to its
/// parent).
#[derive(Debug)]
pub enum BufferCollectionTokenGroupRequest {
    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    Sync { responder: BufferCollectionTokenGroupSyncResponder },
    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    Close { control_handle: BufferCollectionTokenGroupControlHandle },
    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    SetName { priority: u32, name: String, control_handle: BufferCollectionTokenGroupControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    SetDebugClientInfo {
        name: String,
        id: u64,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    SetDebugTimeoutLogDeadline {
        deadline: i64,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    SetVerboseLogging { control_handle: BufferCollectionTokenGroupControlHandle },
    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    GetNodeRef { responder: BufferCollectionTokenGroupGetNodeRefResponder },
    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    IsAlternateFor {
        node_ref: fdomain_client::Event,
        responder: BufferCollectionTokenGroupIsAlternateForResponder,
    },
    /// Create a child token.  Before passing the client end of this token to
    /// BindSharedCollection(), completion of Sync() after CreateChild() is
    /// required.  Or the client can use CreateChildrenSync() which essentially
    /// includes the Sync().
    ///
    /// token_request - the server end of the new token channel.
    ///
    /// rights_attenuation_mask - If ZX_RIGHT_SAME_RIGHTS, the created token
    /// allows the holder to get the same rights to buffers as the parent token
    /// (of the group) had.
    CreateChild {
        payload: BufferCollectionTokenGroupCreateChildRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Create 1 or more child tokens at once, synchronously.  In contrast to
    /// CreateChild(), no Sync() completion is required before passing the
    /// client end of a returned token to BindSharedCollection().
    ///
    /// The size of the rights_attentuation_mask determines the number of
    /// created child tokens.
    ///
    /// The lower-index child tokens are higher priority (attempted sooner) than
    /// higher-index child tokens.
    ///
    /// As per all child tokens, successful aggregation will choose exactly one
    /// child among all created children (across all children created across
    /// potentially multiple calls to CreateChild() and CreateChildrenSync()).
    ///
    /// The maximum permissible total number of children per group, and total
    /// number of nodes in an overall tree (from the root) are capped to limits
    /// which are not configurable via these protocols.
    CreateChildrenSync {
        rights_attenuation_masks: Vec<fidl::Rights>,
        responder: BufferCollectionTokenGroupCreateChildrenSyncResponder,
    },
    /// AllChildrenPresent()
    ///
    /// After creating all children, the client must call AllChildrenPresent()
    /// to inform sysmem that no more children will be created, so that sysmem
    /// can know when it's ok to start aggregating constraints.
    ///
    /// If Close() is to be sent, it should be sent _after_
    /// AllChildrenPresent(), else failure of the group and propagation of the
    /// failure to the group's parent will still be triggered.
    AllChildrenPresent { control_handle: BufferCollectionTokenGroupControlHandle },
}

impl BufferCollectionTokenGroupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(BufferCollectionTokenGroupSyncResponder)> {
        if let BufferCollectionTokenGroupRequest::Sync { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_name(self) -> Option<(u32, String, BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::SetName { priority, name, control_handle } = self
        {
            Some((priority, name, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_client_info(
        self,
    ) -> Option<(String, u64, BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::SetDebugClientInfo { name, id, control_handle } =
            self
        {
            Some((name, id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(i64, BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::SetDebugTimeoutLogDeadline {
            deadline,
            control_handle,
        } = self
        {
            Some((deadline, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_verbose_logging(self) -> Option<(BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::SetVerboseLogging { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_node_ref(self) -> Option<(BufferCollectionTokenGroupGetNodeRefResponder)> {
        if let BufferCollectionTokenGroupRequest::GetNodeRef { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_alternate_for(
        self,
    ) -> Option<(fdomain_client::Event, BufferCollectionTokenGroupIsAlternateForResponder)> {
        if let BufferCollectionTokenGroupRequest::IsAlternateFor { node_ref, responder } = self {
            Some((node_ref, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_child(
        self,
    ) -> Option<(
        BufferCollectionTokenGroupCreateChildRequest,
        BufferCollectionTokenGroupControlHandle,
    )> {
        if let BufferCollectionTokenGroupRequest::CreateChild { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_children_sync(
        self,
    ) -> Option<(Vec<fidl::Rights>, BufferCollectionTokenGroupCreateChildrenSyncResponder)> {
        if let BufferCollectionTokenGroupRequest::CreateChildrenSync {
            rights_attenuation_masks,
            responder,
        } = self
        {
            Some((rights_attenuation_masks, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_all_children_present(self) -> Option<(BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::AllChildrenPresent { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BufferCollectionTokenGroupRequest::Sync { .. } => "sync",
            BufferCollectionTokenGroupRequest::Close { .. } => "close",
            BufferCollectionTokenGroupRequest::SetName { .. } => "set_name",
            BufferCollectionTokenGroupRequest::SetDebugClientInfo { .. } => "set_debug_client_info",
            BufferCollectionTokenGroupRequest::SetDebugTimeoutLogDeadline { .. } => {
                "set_debug_timeout_log_deadline"
            }
            BufferCollectionTokenGroupRequest::SetVerboseLogging { .. } => "set_verbose_logging",
            BufferCollectionTokenGroupRequest::GetNodeRef { .. } => "get_node_ref",
            BufferCollectionTokenGroupRequest::IsAlternateFor { .. } => "is_alternate_for",
            BufferCollectionTokenGroupRequest::CreateChild { .. } => "create_child",
            BufferCollectionTokenGroupRequest::CreateChildrenSync { .. } => "create_children_sync",
            BufferCollectionTokenGroupRequest::AllChildrenPresent { .. } => "all_children_present",
        }
    }
}

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

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

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

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

impl BufferCollectionTokenGroupControlHandle {}

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

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

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

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

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

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

    fn send_raw(&self, mut node_ref: fdomain_client::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeGetNodeRefResponse>(
            (node_ref,),
            self.tx_id,
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>>(
                result.map(|is_alternate| (is_alternate,)),
                self.tx_id,
                0x33a2a7aff2776c07,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut tokens: Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BufferCollectionTokenGroupCreateChildrenSyncResponse>(
            (tokens.as_mut(),),
            self.tx_id,
            0x569dc3ca2a98f535,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for NodeMarker {
    type Proxy = NodeProxy;
    type RequestStream = NodeRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Node";
}
pub type NodeIsAlternateForResult = Result<bool, i32>;

pub trait NodeProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, priority: u32, name: &str) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(&self, name: &str, id: u64) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(&self, deadline: i64) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<fdomain_client::Event, fidl::Error>>
        + Send;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut;
    type IsAlternateForResponseFut: std::future::Future<Output = Result<NodeIsAlternateForResult, fidl::Error>>
        + Send;
    fn r#is_alternate_for(
        &self,
        node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut;
}

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

impl fdomain_client::fidl::Proxy for NodeProxy {
    type Protocol = NodeMarker;

    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 NodeProxy {
    /// Create a new Proxy for fuchsia.sysmem/Node.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <NodeMarker 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) -> NodeEventStream {
        NodeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        NodeProxyInterface::r#sync(self)
    }

    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#close(self)
    }

    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    pub fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_name(self, priority, name)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    pub fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_debug_client_info(self, name, id)
    }

    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    pub fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_debug_timeout_log_deadline(self, deadline)
    }

    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_node_ref(self)
    }

    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    pub fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#is_alternate_for(self, node_ref)
    }
}

impl NodeProxyInterface for NodeProxy {
    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,
                0x4577e238ae26291,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4577e238ae26291,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#set_name(&self, mut priority: u32, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetNameRequest>(
            (priority, name),
            0x77a41bb6217e2443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_client_info(&self, mut name: &str, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugClientInfoRequest>(
            (name, id),
            0x7275759070eb5ee2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_debug_timeout_log_deadline(&self, mut deadline: i64) -> Result<(), fidl::Error> {
        self.client.send::<NodeSetDebugTimeoutLogDeadlineRequest>(
            (deadline,),
            0x46d38f4772638867,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        fdomain_client::Event,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_node_ref(&self) -> Self::GetNodeRefResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_client::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetNodeRefResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x467b7c75c35c3b84,
            >(_buf?)?;
            Ok(_response.node_ref)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fdomain_client::Event>(
            (),
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut node_ref: fdomain_client::Event,
    ) -> Self::IsAlternateForResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeIsAlternateForResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x33a2a7aff2776c07,
            >(_buf?)?;
            Ok(_response.map(|x| x.is_alternate))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            (node_ref,),
            0x33a2a7aff2776c07,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for NodeRequestStream {
    type Protocol = NodeMarker;
    type ControlHandle = NodeControlHandle;

    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 {
        NodeControlHandle { 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 NodeRequestStream {
    type Item = Result<NodeRequest, 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 NodeRequestStream 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 {
                    0x4577e238ae26291 => {
                        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 = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::Sync {
                            responder: NodeSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b1d7a4f5681fca7 => {
                        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 = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::Close { control_handle })
                    }
                    0x77a41bb6217e2443 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetNameRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetNameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetName {
                            priority: req.priority,
                            name: req.name,

                            control_handle,
                        })
                    }
                    0x7275759070eb5ee2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetDebugClientInfoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugClientInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetDebugClientInfo {
                            name: req.name,
                            id: req.id,

                            control_handle,
                        })
                    }
                    0x46d38f4772638867 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetDebugTimeoutLogDeadlineRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetDebugTimeoutLogDeadlineRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetDebugTimeoutLogDeadline {
                            deadline: req.deadline,

                            control_handle,
                        })
                    }
                    0x6bfbe2cf1701d288 => {
                        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 = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetVerboseLogging { control_handle })
                    }
                    0x467b7c75c35c3b84 => {
                        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 = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::GetNodeRef {
                            responder: NodeGetNodeRefResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x33a2a7aff2776c07 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeIsAlternateForRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeIsAlternateForRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::IsAlternateFor {
                            node_ref: req.node_ref,

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

#[derive(Debug)]
pub enum NodeRequest {
    /// Ensure that previous messages, including Duplicate() messages on a
    /// token, collection, or group, have been received server side.
    ///
    /// Calling BufferCollectionToken.Sync() on a token that isn't/wasn't a
    /// valid sysmem token risks the Sync() hanging forever.  See
    /// ValidateBufferCollectionToken() for one way to mitigate the possibility
    /// of a hostile/fake BufferCollectionToken at the cost of one round trip.
    /// Another way is to pass the token to BindSharedCollection(), which also
    /// validates the token as part of exchanging it for a BufferCollection
    /// channel, and BufferCollection Sync() can then be used.
    ///
    /// After a Sync(), it's then safe to send the client end of token_request
    /// to another participant knowing the server will recognize the token when
    /// it's sent into BindSharedCollection() by the other participant.
    ///
    /// Other options include waiting for each token.Duplicate() to complete
    /// individually (using separate call to token.Sync() after each), or
    /// calling Sync() on BufferCollection after the token has been turned in
    /// via BindSharedCollection().
    ///
    /// Another way to mitigate is to avoid calling Sync() on the token, and
    /// instead later deal with potential failure of BufferCollection.Sync() if
    /// the original token was invalid.  This option can be preferable from a
    /// performance point of view, but requires client code to delay sending
    /// tokens duplicated from this token until after client code has converted
    /// the duplicating token to a BufferCollection and received successful
    /// response from BufferCollection.Sync().
    ///
    /// Prefer using BufferCollection.Sync() instead, when feasible (see above).
    /// When BufferCollection.Sync() isn't feasible, the caller must already
    /// know that this token is/was valid, or BufferCollectionToken.Sync() may
    /// hang forever.  See ValidateBufferCollectionToken() to check token
    /// validity first if the token isn't already known to be (is/was) valid.
    Sync { responder: NodeSyncResponder },
    /// On a BufferCollectionToken channel:
    ///
    /// Normally a participant will convert a BufferCollectionToken into a
    /// BufferCollection view, but a participant is also free to Close() the
    /// token (and then close the channel immediately or shortly later in
    /// response to server closing its end), which avoids causing logical buffer
    /// collection failure.  Normally an unexpected token channel close will
    /// cause logical buffer collection failure (the only exceptions being
    /// certain cases involving AttachToken() or SetDispensable()).
    ///
    /// On a BufferCollection channel:
    ///
    /// By default the server handles unexpected failure of a BufferCollection
    /// by failing the whole logical buffer collection.  Partly this is to
    /// expedite closing VMO handles to reclaim memory when any participant
    /// fails.  If a participant would like to cleanly close a BufferCollection
    /// view without causing logical buffer collection failure, the participant
    /// can send Close() before closing the client end of the BufferCollection
    /// channel.  If this is the last BufferCollection view, the logical buffer
    /// collection will still go away.  The Close() can occur before or after
    /// SetConstraints().  If before SetConstraints(), the buffer collection
    /// won't require constraints from this node in order to allocate.  If
    /// after SetConstraints(), the constraints are retained and aggregated
    /// along with any subsequent logical allocation(s), despite the lack of
    /// channel connection.
    ///
    /// On a BufferCollectionTokenGroup channel:
    ///
    /// By default, unexpected failure of a BufferCollectionTokenGroup will
    /// trigger failure of the logical BufferCollectionTokenGroup and will
    /// propagate failure to its parent.  To close a BufferCollectionTokenGroup
    /// channel without failing the logical group or propagating failure, send
    /// Close() before closing the channel client endpoint.
    ///
    /// If Close() occurs before AllChildrenPresent(), the logical buffer
    /// collection will still fail despite the Close() (because sysmem can't be
    /// sure whether all relevant children were created, so it's ambiguous
    /// whether all relevant constraints will be provided to sysmem).  If
    /// Close() occurs after AllChildrenPresent(), the children and all their
    /// constraints remain intact (just as they would if the
    /// BufferCollectionTokenGroup channel had remained open), and the close
    /// doesn't trigger or propagate failure.
    Close { control_handle: NodeControlHandle },
    /// Set a name for VMOs in this buffer collection. The name may be truncated
    /// shorter. The name only affects VMOs allocated after it's set - this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win.
    SetName { priority: u32, name: String, control_handle: NodeControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help debug leaking memory and hangs waiting for constraints. |name| can
    /// be an arbitrary string, but the current process name (see
    /// fsl::GetCurrentProcessName()) is a good default. |id| can be an
    /// arbitrary id, but the current process ID (see
    /// fsl::GetCurrentProcessKoid()) is a good default.
    ///
    /// Also used when verbose logging is enabled (see SetVerboseLogging()) to
    /// indicate which client is closing their channel first, leading to
    /// sub-tree failure (which can be normal if the purpose of the sub-tree is
    /// over, but if happening earlier than expected, the
    /// client-channel-specific name can help diagnose where the failure is
    /// first coming from, from sysmem's point of view).
    ///
    /// By default (unless overriden by this message or using
    /// Allocator.SetDebugClientInfo()), a Node will copy info from its
    /// parent Node at the time the child Node is created.  While this can be
    /// better than nothing, it's often better for each participant to use
    /// Node.SetDebugClientInfo() or Allocator.SetDebugClientInfo() to keep the
    /// info directly relevant to the current client.  Also, SetVerboseLogging()
    /// can be used to help disambiguate if a Node is suspected of having info
    /// that was copied from its parent.
    SetDebugClientInfo { name: String, id: u64, control_handle: NodeControlHandle },
    /// Sysmem logs a warning if not all clients have set constraints 5 seconds
    /// after creating a collection. Clients can call this method to change
    /// when the log is printed. If multiple client set the deadline, it's
    /// unspecified which deadline will take effect.
    SetDebugTimeoutLogDeadline { deadline: i64, control_handle: NodeControlHandle },
    /// Verbose logging includes constraints set via SetConstraints() from each
    /// client along with info set via SetDebugClientInfo() and the structure of
    /// the tree of Node(s).
    ///
    /// Normally sysmem prints only a single line complaint when aggregation
    /// fails, with just the specific detailed reason that aggregation failed,
    /// with minimal context.  While this is often enough to diagnose a problem
    /// if only a small change was made and the system had been working before
    /// the small change, it's often not particularly helpful for getting a new
    /// buffer collection to work for the first time.  Especially with more
    /// complex trees of nodes, involving things like AttachToken(),
    /// SetDispensable(), BufferCollectionTokenGroup nodes, and associated
    /// sub-trees of nodes, verbose logging may help in diagnosing what the tree
    /// looks like and why it's failing a logical allocation, or why a tree or
    /// sub-tree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, if only enabled on a low number of buffer collections.
    /// If we're not tracking down a bug, we shouldn't send this message.
    ///
    /// If too many participants leave verbose logging enabled, we may end up
    /// needing to require that system-wide sysmem verbose logging be permitted
    /// via some other setting, to avoid sysmem spamming the log too much due to
    /// this message.
    ///
    /// This may be a NOP for some nodes due to intentional policy associated
    /// with the node, if we don't trust a node enough to let it turn on verbose
    /// logging.
    SetVerboseLogging { control_handle: NodeControlHandle },
    /// This gets an event handle that can be used as a parameter to
    /// IsAlternateFor() called on any Node.  The client will not be granted the
    /// right to signal this event, as this handle should only be used as proof
    /// that the client obtained this handle from this Node.
    ///
    /// Because this is a get not a set, no Sync() is needed between the
    /// GetNodeRef() and the call to IsAlternateFor(), despite the two calls
    /// potentially being on different channels.
    ///
    /// See also IsAlternateFor().
    GetNodeRef { responder: NodeGetNodeRefResponder },
    /// This checks whether the calling node is in a subtree rooted at a
    /// different child token of a common parent BufferCollectionTokenGroup, in
    /// relation to the passed-in node_ref.
    ///
    /// This call is for assisting with admission control de-duplication, and
    /// with debugging.
    ///
    /// The node_ref must be obtained using GetNodeRef() of a
    /// BufferCollectionToken, BufferCollection, or BufferCollectionTokenGroup.
    ///
    /// The node_ref can be a duplicated handle; it's not necessary to call
    /// GetNodeRef() for every call to IsAlternateFor().
    ///
    /// If a calling token may not actually be a valid token at all due to
    /// a potentially hostile/untrusted provider of the token, call
    /// ValidateBufferCollectionToken() first instead of potentially getting
    /// stuck indefinitely if IsAlternateFor() never responds due to a calling
    /// token not being a real token (not really talking to sysmem).  Another
    /// option is to call BindSharedCollection with this token first which also
    /// validates the token along with converting it to a BufferCollection, then
    /// call BufferCollection IsAlternateFor().
    ///
    /// error values:
    ///
    /// ZX_ERR_NOT_FOUND means the node_ref wasn't found within the same logical
    /// buffer collection as the calling Node.  Before logical allocation and
    /// within the same logical allocation sub-tree, this essentially means that
    /// the node_ref was never part of this logical buffer collection, since
    /// before logical allocation all node_refs that come into existence remain
    /// in existence at least until logical allocation (including Node(s) that
    /// have done a Close() and closed their channel), and for ZX_ERR_NOT_FOUND
    /// to be returned, this Node's channel needs to still be connected server
    /// side, which won't be the case if the whole logical allocation has
    /// failed.  After logical allocation or in a different logical allocation
    /// sub-tree there are additional potential reasons for this error.  For
    /// example a different logical allocation (separated from this Node(s)
    /// logical allocation by an AttachToken() or SetDispensable()) can fail its
    /// sub-tree deleting those Node(s), or a BufferCollectionTokenGroup may
    /// exist and may select a different child sub-tree than the sub-tree the
    /// node_ref is in causing deletion of the node_ref Node.  The only time
    /// sysmem keeps a Node around after that Node has no corresponding channel
    /// is when Close() is used and the Node's sub-tree has not yet failed.
    /// Another reason for this error is if the node_ref is an eventpair handle
    /// with sufficient rights, but isn't actually a real node_ref obtained from
    /// GetNodeRef().
    ///
    /// ZX_ERR_INVALID_ARGS means the caller passed a node_ref that isn't an
    /// eventpair handle, or doesn't have the needed rights expected on a real
    /// node_ref.
    ///
    /// No other failing status codes are returned by this call.  However,
    /// sysmem may add additional codes in future, so the client should have
    /// sensible default handling for any failing status code.
    ///
    /// On success, is_alternate has the following meaning:
    ///   * true - The first parent node in common between the calling node and
    ///     the node_ref Node is a BufferCollectionTokenGroup.  This means that
    ///     the calling Node and the node_ref Node will _not_ have both their
    ///     constraints apply - rather sysmem will choose one or the other of
    ///     the constraints - never both.  This is because only one child of
    ///     a BufferCollectionTokenGroup is selected during logical allocation,
    ///     with only that one child's sub-tree contributing to constraints
    ///     aggregation.
    ///   * false - The first parent node in common between the calling Node and
    ///     the node_ref Node is not a BufferCollectionTokenGroup.  Currently,
    ///     this means the first parent node in common is a
    ///     BufferCollectionToken or BufferCollection (regardless of not
    ///     Close()ed or Close()ed).  This means that the calling Node and the
    ///     node_ref Node _may_ have both their constraints apply during
    ///     constraints aggregation of the logical allocation, if both Node(s)
    ///     are selected by any parent BufferCollectionTokenGroup(s) involved.
    ///     In this case, there is no BufferCollectionTokenGroup that will
    ///     directly prevent the two Node(s) from both being selected and their
    ///     constraints both aggregated, but even when false, one or both
    ///     Node(s) may still be eliminated from consideration if one or both
    ///     Node(s) has a direct or indirect parent BufferCollectionTokenGroup
    ///     which selects a child sub-tree other than the sub-tree containing
    ///     the calling Node or node_ref Node.
    IsAlternateFor { node_ref: fdomain_client::Event, responder: NodeIsAlternateForResponder },
}

impl NodeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(NodeSyncResponder)> {
        if let NodeRequest::Sync { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(NodeControlHandle)> {
        if let NodeRequest::Close { control_handle } = self { Some((control_handle)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_name(self) -> Option<(u32, String, NodeControlHandle)> {
        if let NodeRequest::SetName { priority, name, control_handle } = self {
            Some((priority, name, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_client_info(self) -> Option<(String, u64, NodeControlHandle)> {
        if let NodeRequest::SetDebugClientInfo { name, id, control_handle } = self {
            Some((name, id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(self) -> Option<(i64, NodeControlHandle)> {
        if let NodeRequest::SetDebugTimeoutLogDeadline { deadline, control_handle } = self {
            Some((deadline, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_verbose_logging(self) -> Option<(NodeControlHandle)> {
        if let NodeRequest::SetVerboseLogging { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_node_ref(self) -> Option<(NodeGetNodeRefResponder)> {
        if let NodeRequest::GetNodeRef { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_alternate_for(
        self,
    ) -> Option<(fdomain_client::Event, NodeIsAlternateForResponder)> {
        if let NodeRequest::IsAlternateFor { node_ref, responder } = self {
            Some((node_ref, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NodeRequest::Sync { .. } => "sync",
            NodeRequest::Close { .. } => "close",
            NodeRequest::SetName { .. } => "set_name",
            NodeRequest::SetDebugClientInfo { .. } => "set_debug_client_info",
            NodeRequest::SetDebugTimeoutLogDeadline { .. } => "set_debug_timeout_log_deadline",
            NodeRequest::SetVerboseLogging { .. } => "set_verbose_logging",
            NodeRequest::GetNodeRef { .. } => "get_node_ref",
            NodeRequest::IsAlternateFor { .. } => "is_alternate_for",
        }
    }
}

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

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

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

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

impl NodeControlHandle {}

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

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

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

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

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

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

    fn send_raw(&self, mut node_ref: fdomain_client::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeGetNodeRefResponse>(
            (node_ref,),
            self.tx_id,
            0x467b7c75c35c3b84,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<NodeIsAlternateForResponse, i32>>(
                result.map(|is_alternate| (is_alternate,)),
                self.tx_id,
                0x33a2a7aff2776c07,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for SecureMemMarker {
    type Proxy = SecureMemProxy;
    type RequestStream = SecureMemRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) SecureMem";
}
pub type SecureMemGetPhysicalSecureHeapsResult = Result<SecureHeapsAndRanges, i32>;
pub type SecureMemGetPhysicalSecureHeapPropertiesResult = Result<SecureHeapProperties, i32>;
pub type SecureMemAddSecureHeapPhysicalRangeResult = Result<(), i32>;
pub type SecureMemDeleteSecureHeapPhysicalRangeResult = Result<(), i32>;
pub type SecureMemModifySecureHeapPhysicalRangeResult = Result<(), i32>;
pub type SecureMemZeroSubRangeResult = Result<(), i32>;

pub trait SecureMemProxyInterface: Send + Sync {
    type GetPhysicalSecureHeapsResponseFut: std::future::Future<Output = Result<SecureMemGetPhysicalSecureHeapsResult, fidl::Error>>
        + Send;
    fn r#get_physical_secure_heaps(&self) -> Self::GetPhysicalSecureHeapsResponseFut;
    type GetPhysicalSecureHeapPropertiesResponseFut: std::future::Future<
            Output = Result<SecureMemGetPhysicalSecureHeapPropertiesResult, fidl::Error>,
        > + Send;
    fn r#get_physical_secure_heap_properties(
        &self,
        entire_heap: &SecureHeapAndRange,
    ) -> Self::GetPhysicalSecureHeapPropertiesResponseFut;
    type AddSecureHeapPhysicalRangeResponseFut: std::future::Future<Output = Result<SecureMemAddSecureHeapPhysicalRangeResult, fidl::Error>>
        + Send;
    fn r#add_secure_heap_physical_range(
        &self,
        heap_range: &SecureHeapAndRange,
    ) -> Self::AddSecureHeapPhysicalRangeResponseFut;
    type DeleteSecureHeapPhysicalRangeResponseFut: std::future::Future<
            Output = Result<SecureMemDeleteSecureHeapPhysicalRangeResult, fidl::Error>,
        > + Send;
    fn r#delete_secure_heap_physical_range(
        &self,
        heap_range: &SecureHeapAndRange,
    ) -> Self::DeleteSecureHeapPhysicalRangeResponseFut;
    type ModifySecureHeapPhysicalRangeResponseFut: std::future::Future<
            Output = Result<SecureMemModifySecureHeapPhysicalRangeResult, fidl::Error>,
        > + Send;
    fn r#modify_secure_heap_physical_range(
        &self,
        range_modification: &SecureHeapAndRangeModification,
    ) -> Self::ModifySecureHeapPhysicalRangeResponseFut;
    type ZeroSubRangeResponseFut: std::future::Future<Output = Result<SecureMemZeroSubRangeResult, fidl::Error>>
        + Send;
    fn r#zero_sub_range(
        &self,
        is_covering_range_explicit: bool,
        heap_range: &SecureHeapAndRange,
    ) -> Self::ZeroSubRangeResponseFut;
}

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

impl fdomain_client::fidl::Proxy for SecureMemProxy {
    type Protocol = SecureMemMarker;

    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 SecureMemProxy {
    /// Create a new Proxy for fuchsia.sysmem/SecureMem.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SecureMemMarker 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) -> SecureMemEventStream {
        SecureMemEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the physical address and length of any secure heap whose physical
    /// range is configured via the TEE.
    ///
    /// Presently, these will be fixed physical addresses and lengths, with the
    /// location plumbed via the TEE.
    ///
    /// This is preferred over ['fuchsia.hardware.sysmem.Sysmem/RegisterHeap']
    /// when there isn't any special heap-specific per-VMO setup or teardown
    /// required.
    ///
    /// The physical range must be secured/protected by the TEE before the
    /// securemem driver responds to this request with success.
    ///
    /// Sysmem should only call this once.  Returning zero heaps is not a
    /// failure.
    ///
    /// Errors:
    ///  * ZX_ERR_BAD_STATE - called more than once.
    ///  * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///    with TEE which doesn't generate zx_status_t errors).
    ///  * other errors are allowed; any other errors should be treated the same
    ///    as ZX_ERR_INTERNAL.
    pub fn r#get_physical_secure_heaps(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#get_physical_secure_heaps(self)
    }

    /// This request from sysmem to the securemem driver gets the properties of
    /// a protected/secure heap.
    ///
    /// This only handles heaps with a single contiguous physical extent.
    ///
    /// The heap's entire physical range is indicated in case this request needs
    /// some physical space to auto-detect how many ranges are REE-usable.  Any
    /// temporary HW protection ranges will be deleted before this request
    /// completes.
    pub fn r#get_physical_secure_heap_properties(
        &self,
        mut entire_heap: &SecureHeapAndRange,
    ) -> fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapPropertiesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#get_physical_secure_heap_properties(self, entire_heap)
    }

    /// This request from sysmem to the securemem driver conveys a physical
    /// range to add, for a heap whose physical range(s) are set up via
    /// sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure all the covered offsets as protected
    /// before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the protected range was not
    /// created.
    ///
    /// Sysmem must only call this up to once if dynamic_protection_ranges
    /// false.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this multiple
    /// times as long as the current number of ranges never exceeds
    /// max_protected_range_count.
    ///
    /// The caller must not attempt to add a range that matches an
    /// already-existing range.  Added ranges can overlap each other as long as
    /// no two ranges match exactly.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called more than once when
    ///     !dynamic_protection_ranges.  Adding a heap that would cause overall
    ///     heap count to exceed max_protected_range_count.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or range that doesn't conform
    ///     to protected_range_granularity.
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    pub fn r#add_secure_heap_physical_range(
        &self,
        mut heap_range: &SecureHeapAndRange,
    ) -> fidl::client::QueryResponseFut<
        SecureMemAddSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#add_secure_heap_physical_range(self, heap_range)
    }

    /// This request from sysmem to the securemem driver conveys a physical
    /// range to delete, for a heap whose physical range(s) are set up via
    /// sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure all the covered offsets as not
    /// protected before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the protected range was not
    /// deleted.
    ///
    /// Sysmem must not call this if dynamic_protection_ranges false.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this repeatedly,
    /// on various ranges that exist at the time of the call.
    ///
    /// If any portion of the range being deleted is not also covered by another
    /// protected range, then any ongoing DMA to any part of the entire range
    /// may be interrupted / may fail, potentially in a way that's disruptive to
    /// the entire system (bus lockup or similar, depending on device details).
    /// Therefore, the caller must ensure that no ongoing DMA is occurring to
    /// any portion of the range being deleted, unless the caller has other
    /// active ranges covering every block of the range being deleted.  Ongoing
    /// DMA to/from blocks outside the range being deleted is never impacted by
    /// the deletion.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called when !dynamic_protection_ranges.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or range that doesn't conform
    ///     to protected_range_granularity.
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * ZX_ERR_NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    pub fn r#delete_secure_heap_physical_range(
        &self,
        mut heap_range: &SecureHeapAndRange,
    ) -> fidl::client::QueryResponseFut<
        SecureMemDeleteSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#delete_secure_heap_physical_range(self, heap_range)
    }

    /// This request from sysmem to the securemem driver conveys a physical
    /// range to modify and its new base and length, for a heap whose physical
    /// range(s) are set up via sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure the range to cover only the new
    /// offsets before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the range was not changed.
    ///
    /// Sysmem must not call this if dynamic_protection_ranges false.  Sysmem
    /// must not call this if !is_mod_protected_range_available.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this repeatedly,
    /// on various ranges that exist at the time of the call.
    ///
    /// The range must only be modified at one end or the other, but not both.
    /// If the range is getting shorter, and the un-covered blocks are not
    /// covered by other active ranges, any ongoing DMA to the entire range
    /// that's geting shorter may fail in a way that disrupts the entire system
    /// (bus lockup or similar), so the caller must ensure that no DMA is
    /// ongoing to any portion of a range that is getting shorter, unless the
    /// blocks being un-covered by the modification to this range are all
    /// covered by other active ranges, in which case no disruption to ongoing
    /// DMA will occur.
    ///
    /// If a range is modified to become <= zero length, the range is deleted.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called when !dynamic_protection_ranges.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or old_range or new_range
    ///     that doesn't conform to protected_range_granularity, or old_range
    ///     and new_range differ in both begin and end (disallowed).
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * ZX_ERR_NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    pub fn r#modify_secure_heap_physical_range(
        &self,
        mut range_modification: &SecureHeapAndRangeModification,
    ) -> fidl::client::QueryResponseFut<
        SecureMemModifySecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#modify_secure_heap_physical_range(self, range_modification)
    }

    /// Zero a sub-range of a currently-existing physical range added via
    /// AddSecureHeapPhysicalRange().  The sub-range must be fully covered by
    /// exactly one physical range, and must not overlap with any other
    /// physical range.
    ///
    /// is_covering_range_explicit - When true, the covering range must be one
    ///     of the ranges explicitly created via AddSecureHeapPhysicalRange(),
    ///     possibly modified since.  When false, the covering range must not
    ///     be one of the ranges explicitly created via
    ///     AddSecureHeapPhysicalRange(), but the covering range must exist as
    ///     a covering range not created via AddSecureHeapPhysicalRange().  The
    ///     covering range is typically the entire physical range (or a range
    ///     which covers even more) of a heap configured by the TEE and whose
    ///     configuration is conveyed to sysmem via GetPhysicalSecureHeaps().
    ///
    /// Ongoing DMA is not disrupted by this request.
    pub fn r#zero_sub_range(
        &self,
        mut is_covering_range_explicit: bool,
        mut heap_range: &SecureHeapAndRange,
    ) -> fidl::client::QueryResponseFut<
        SecureMemZeroSubRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#zero_sub_range(self, is_covering_range_explicit, heap_range)
    }
}

impl SecureMemProxyInterface for SecureMemProxy {
    type GetPhysicalSecureHeapsResponseFut = fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_physical_secure_heaps(&self) -> Self::GetPhysicalSecureHeapsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemGetPhysicalSecureHeapsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SecureMemGetPhysicalSecureHeapsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x782319d6ce7fa05,
            >(_buf?)?;
            Ok(_response.map(|x| x.heaps))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            SecureMemGetPhysicalSecureHeapsResult,
        >(
            (),
            0x782319d6ce7fa05,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPhysicalSecureHeapPropertiesResponseFut = fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapPropertiesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_physical_secure_heap_properties(
        &self,
        mut entire_heap: &SecureHeapAndRange,
    ) -> Self::GetPhysicalSecureHeapPropertiesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemGetPhysicalSecureHeapPropertiesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SecureMemGetPhysicalSecureHeapPropertiesResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x26404e23f1271214,
            >(_buf?)?;
            Ok(_response.map(|x| x.properties))
        }
        self.client.send_query_and_decode::<
            SecureMemGetPhysicalSecureHeapPropertiesRequest,
            SecureMemGetPhysicalSecureHeapPropertiesResult,
        >(
            (entire_heap,),
            0x26404e23f1271214,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddSecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemAddSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_secure_heap_physical_range(
        &self,
        mut heap_range: &SecureHeapAndRange,
    ) -> Self::AddSecureHeapPhysicalRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemAddSecureHeapPhysicalRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1ca1abcee8a0b33e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemAddSecureHeapPhysicalRangeRequest,
            SecureMemAddSecureHeapPhysicalRangeResult,
        >(
            (heap_range,),
            0x1ca1abcee8a0b33e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeleteSecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemDeleteSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#delete_secure_heap_physical_range(
        &self,
        mut heap_range: &SecureHeapAndRange,
    ) -> Self::DeleteSecureHeapPhysicalRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemDeleteSecureHeapPhysicalRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x728a953e56df92ee,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemDeleteSecureHeapPhysicalRangeRequest,
            SecureMemDeleteSecureHeapPhysicalRangeResult,
        >(
            (heap_range,),
            0x728a953e56df92ee,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ModifySecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemModifySecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#modify_secure_heap_physical_range(
        &self,
        mut range_modification: &SecureHeapAndRangeModification,
    ) -> Self::ModifySecureHeapPhysicalRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemModifySecureHeapPhysicalRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x154fbfa3646a890d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemModifySecureHeapPhysicalRangeRequest,
            SecureMemModifySecureHeapPhysicalRangeResult,
        >(
            (range_modification,),
            0x154fbfa3646a890d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ZeroSubRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemZeroSubRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#zero_sub_range(
        &self,
        mut is_covering_range_explicit: bool,
        mut heap_range: &SecureHeapAndRange,
    ) -> Self::ZeroSubRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemZeroSubRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7480f72bb5bc7e5b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<SecureMemZeroSubRangeRequest, SecureMemZeroSubRangeResult>(
                (is_covering_range_explicit, heap_range),
                0x7480f72bb5bc7e5b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for SecureMemRequestStream {
    type Protocol = SecureMemMarker;
    type ControlHandle = SecureMemControlHandle;

    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 {
        SecureMemControlHandle { 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 SecureMemRequestStream {
    type Item = Result<SecureMemRequest, 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 SecureMemRequestStream 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 {
                    0x782319d6ce7fa05 => {
                        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 = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::GetPhysicalSecureHeaps {
                            responder: SecureMemGetPhysicalSecureHeapsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x26404e23f1271214 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SecureMemGetPhysicalSecureHeapPropertiesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SecureMemGetPhysicalSecureHeapPropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::GetPhysicalSecureHeapProperties {
                            entire_heap: req.entire_heap,

                            responder: SecureMemGetPhysicalSecureHeapPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ca1abcee8a0b33e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SecureMemAddSecureHeapPhysicalRangeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SecureMemAddSecureHeapPhysicalRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::AddSecureHeapPhysicalRange {
                            heap_range: req.heap_range,

                            responder: SecureMemAddSecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x728a953e56df92ee => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SecureMemDeleteSecureHeapPhysicalRangeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SecureMemDeleteSecureHeapPhysicalRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::DeleteSecureHeapPhysicalRange {
                            heap_range: req.heap_range,

                            responder: SecureMemDeleteSecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x154fbfa3646a890d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SecureMemModifySecureHeapPhysicalRangeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SecureMemModifySecureHeapPhysicalRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::ModifySecureHeapPhysicalRange {
                            range_modification: req.range_modification,

                            responder: SecureMemModifySecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7480f72bb5bc7e5b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SecureMemZeroSubRangeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<SecureMemZeroSubRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SecureMemControlHandle { inner: this.inner.clone() };
                        Ok(SecureMemRequest::ZeroSubRange {
                            is_covering_range_explicit: req.is_covering_range_explicit,
                            heap_range: req.heap_range,

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

/// SecureMem
///
/// The client is sysmem.  The server is securemem driver.
///
/// TEE - Trusted Execution Environment.
///
/// REE - Rich Execution Environment.
///
/// Enables sysmem to call the securemem driver to get any secure heaps
/// configured via the TEE (or via the securemem driver), and set any physical
/// secure heaps configured via sysmem.
///
/// Presently, dynamically-allocated secure heaps are configured via sysmem, as
/// it starts quite early during boot and can successfully reserve contiguous
/// physical memory.  Presently, fixed-location secure heaps are configured via
/// TEE, as the plumbing goes from the bootloader to the TEE.  However, this
/// protocol intentionally doesn't care which heaps are dynamically-allocated
/// and which are fixed-location.
#[derive(Debug)]
pub enum SecureMemRequest {
    /// Gets the physical address and length of any secure heap whose physical
    /// range is configured via the TEE.
    ///
    /// Presently, these will be fixed physical addresses and lengths, with the
    /// location plumbed via the TEE.
    ///
    /// This is preferred over ['fuchsia.hardware.sysmem.Sysmem/RegisterHeap']
    /// when there isn't any special heap-specific per-VMO setup or teardown
    /// required.
    ///
    /// The physical range must be secured/protected by the TEE before the
    /// securemem driver responds to this request with success.
    ///
    /// Sysmem should only call this once.  Returning zero heaps is not a
    /// failure.
    ///
    /// Errors:
    ///  * ZX_ERR_BAD_STATE - called more than once.
    ///  * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///    with TEE which doesn't generate zx_status_t errors).
    ///  * other errors are allowed; any other errors should be treated the same
    ///    as ZX_ERR_INTERNAL.
    GetPhysicalSecureHeaps { responder: SecureMemGetPhysicalSecureHeapsResponder },
    /// This request from sysmem to the securemem driver gets the properties of
    /// a protected/secure heap.
    ///
    /// This only handles heaps with a single contiguous physical extent.
    ///
    /// The heap's entire physical range is indicated in case this request needs
    /// some physical space to auto-detect how many ranges are REE-usable.  Any
    /// temporary HW protection ranges will be deleted before this request
    /// completes.
    GetPhysicalSecureHeapProperties {
        entire_heap: SecureHeapAndRange,
        responder: SecureMemGetPhysicalSecureHeapPropertiesResponder,
    },
    /// This request from sysmem to the securemem driver conveys a physical
    /// range to add, for a heap whose physical range(s) are set up via
    /// sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure all the covered offsets as protected
    /// before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the protected range was not
    /// created.
    ///
    /// Sysmem must only call this up to once if dynamic_protection_ranges
    /// false.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this multiple
    /// times as long as the current number of ranges never exceeds
    /// max_protected_range_count.
    ///
    /// The caller must not attempt to add a range that matches an
    /// already-existing range.  Added ranges can overlap each other as long as
    /// no two ranges match exactly.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called more than once when
    ///     !dynamic_protection_ranges.  Adding a heap that would cause overall
    ///     heap count to exceed max_protected_range_count.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or range that doesn't conform
    ///     to protected_range_granularity.
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    AddSecureHeapPhysicalRange {
        heap_range: SecureHeapAndRange,
        responder: SecureMemAddSecureHeapPhysicalRangeResponder,
    },
    /// This request from sysmem to the securemem driver conveys a physical
    /// range to delete, for a heap whose physical range(s) are set up via
    /// sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure all the covered offsets as not
    /// protected before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the protected range was not
    /// deleted.
    ///
    /// Sysmem must not call this if dynamic_protection_ranges false.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this repeatedly,
    /// on various ranges that exist at the time of the call.
    ///
    /// If any portion of the range being deleted is not also covered by another
    /// protected range, then any ongoing DMA to any part of the entire range
    /// may be interrupted / may fail, potentially in a way that's disruptive to
    /// the entire system (bus lockup or similar, depending on device details).
    /// Therefore, the caller must ensure that no ongoing DMA is occurring to
    /// any portion of the range being deleted, unless the caller has other
    /// active ranges covering every block of the range being deleted.  Ongoing
    /// DMA to/from blocks outside the range being deleted is never impacted by
    /// the deletion.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called when !dynamic_protection_ranges.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or range that doesn't conform
    ///     to protected_range_granularity.
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * ZX_ERR_NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    DeleteSecureHeapPhysicalRange {
        heap_range: SecureHeapAndRange,
        responder: SecureMemDeleteSecureHeapPhysicalRangeResponder,
    },
    /// This request from sysmem to the securemem driver conveys a physical
    /// range to modify and its new base and length, for a heap whose physical
    /// range(s) are set up via sysmem.
    ///
    /// Only sysmem can call this because only sysmem is handed the client end
    /// of a FIDL channel serving this protocol, via RegisterSecureMem().  The
    /// securemem driver is the server end of this protocol.
    ///
    /// The securemem driver must configure the range to cover only the new
    /// offsets before responding to this message with success.
    ///
    /// On failure, the securemem driver must ensure the range was not changed.
    ///
    /// Sysmem must not call this if dynamic_protection_ranges false.  Sysmem
    /// must not call this if !is_mod_protected_range_available.
    ///
    /// If dynamic_protection_ranges is true, sysmem can call this repeatedly,
    /// on various ranges that exist at the time of the call.
    ///
    /// The range must only be modified at one end or the other, but not both.
    /// If the range is getting shorter, and the un-covered blocks are not
    /// covered by other active ranges, any ongoing DMA to the entire range
    /// that's geting shorter may fail in a way that disrupts the entire system
    /// (bus lockup or similar), so the caller must ensure that no DMA is
    /// ongoing to any portion of a range that is getting shorter, unless the
    /// blocks being un-covered by the modification to this range are all
    /// covered by other active ranges, in which case no disruption to ongoing
    /// DMA will occur.
    ///
    /// If a range is modified to become <= zero length, the range is deleted.
    ///
    /// Errors:
    ///   * ZX_ERR_BAD_STATE - called when !dynamic_protection_ranges.
    ///   * ZX_ERR_INVALID_ARGS - unexpected heap, or old_range or new_range
    ///     that doesn't conform to protected_range_granularity, or old_range
    ///     and new_range differ in both begin and end (disallowed).
    ///   * ZX_ERR_INTERNAL - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * ZX_ERR_NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of zx_status_t failures.
    ModifySecureHeapPhysicalRange {
        range_modification: SecureHeapAndRangeModification,
        responder: SecureMemModifySecureHeapPhysicalRangeResponder,
    },
    /// Zero a sub-range of a currently-existing physical range added via
    /// AddSecureHeapPhysicalRange().  The sub-range must be fully covered by
    /// exactly one physical range, and must not overlap with any other
    /// physical range.
    ///
    /// is_covering_range_explicit - When true, the covering range must be one
    ///     of the ranges explicitly created via AddSecureHeapPhysicalRange(),
    ///     possibly modified since.  When false, the covering range must not
    ///     be one of the ranges explicitly created via
    ///     AddSecureHeapPhysicalRange(), but the covering range must exist as
    ///     a covering range not created via AddSecureHeapPhysicalRange().  The
    ///     covering range is typically the entire physical range (or a range
    ///     which covers even more) of a heap configured by the TEE and whose
    ///     configuration is conveyed to sysmem via GetPhysicalSecureHeaps().
    ///
    /// Ongoing DMA is not disrupted by this request.
    ZeroSubRange {
        is_covering_range_explicit: bool,
        heap_range: SecureHeapAndRange,
        responder: SecureMemZeroSubRangeResponder,
    },
}

impl SecureMemRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_physical_secure_heaps(
        self,
    ) -> Option<(SecureMemGetPhysicalSecureHeapsResponder)> {
        if let SecureMemRequest::GetPhysicalSecureHeaps { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_physical_secure_heap_properties(
        self,
    ) -> Option<(SecureHeapAndRange, SecureMemGetPhysicalSecureHeapPropertiesResponder)> {
        if let SecureMemRequest::GetPhysicalSecureHeapProperties { entire_heap, responder } = self {
            Some((entire_heap, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_secure_heap_physical_range(
        self,
    ) -> Option<(SecureHeapAndRange, SecureMemAddSecureHeapPhysicalRangeResponder)> {
        if let SecureMemRequest::AddSecureHeapPhysicalRange { heap_range, responder } = self {
            Some((heap_range, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_delete_secure_heap_physical_range(
        self,
    ) -> Option<(SecureHeapAndRange, SecureMemDeleteSecureHeapPhysicalRangeResponder)> {
        if let SecureMemRequest::DeleteSecureHeapPhysicalRange { heap_range, responder } = self {
            Some((heap_range, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_modify_secure_heap_physical_range(
        self,
    ) -> Option<(SecureHeapAndRangeModification, SecureMemModifySecureHeapPhysicalRangeResponder)>
    {
        if let SecureMemRequest::ModifySecureHeapPhysicalRange { range_modification, responder } =
            self
        {
            Some((range_modification, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_zero_sub_range(
        self,
    ) -> Option<(bool, SecureHeapAndRange, SecureMemZeroSubRangeResponder)> {
        if let SecureMemRequest::ZeroSubRange {
            is_covering_range_explicit,
            heap_range,
            responder,
        } = self
        {
            Some((is_covering_range_explicit, heap_range, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SecureMemRequest::GetPhysicalSecureHeaps { .. } => "get_physical_secure_heaps",
            SecureMemRequest::GetPhysicalSecureHeapProperties { .. } => {
                "get_physical_secure_heap_properties"
            }
            SecureMemRequest::AddSecureHeapPhysicalRange { .. } => "add_secure_heap_physical_range",
            SecureMemRequest::DeleteSecureHeapPhysicalRange { .. } => {
                "delete_secure_heap_physical_range"
            }
            SecureMemRequest::ModifySecureHeapPhysicalRange { .. } => {
                "modify_secure_heap_physical_range"
            }
            SecureMemRequest::ZeroSubRange { .. } => "zero_sub_range",
        }
    }
}

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

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

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

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

impl SecureMemControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<&SecureHeapsAndRanges, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            SecureMemGetPhysicalSecureHeapsResponse,
            i32,
        >>(
            result.map(|heaps| (heaps,)),
            self.tx_id,
            0x782319d6ce7fa05,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&SecureHeapProperties, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            SecureMemGetPhysicalSecureHeapPropertiesResponse,
            i32,
        >>(
            result.map(|properties| (properties,)),
            self.tx_id,
            0x26404e23f1271214,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x1ca1abcee8a0b33e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x728a953e56df92ee,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x154fbfa3646a890d,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x7480f72bb5bc7e5b,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

mod internal {
    use super::*;

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for BufferCollectionAttachLifetimeTrackingRequest {
        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 BufferCollectionAttachLifetimeTrackingRequest {
        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<
            BufferCollectionAttachLifetimeTrackingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionAttachLifetimeTrackingRequest
    {
        #[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::<BufferCollectionAttachLifetimeTrackingRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BufferCollectionAttachLifetimeTrackingRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.server_end
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffers_remaining),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            BufferCollectionAttachLifetimeTrackingRequest,
            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::<BufferCollectionAttachLifetimeTrackingRequest>(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 BufferCollectionAttachLifetimeTrackingRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                server_end: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                buffers_remaining: fidl::new_empty!(
                    u32,
                    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::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.server_end, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffers_remaining,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<BufferCollectionInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut BufferCollectionInfo
    {
        #[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::<BufferCollectionInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BufferCollectionInfo,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_count),
                    <BufferFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.format),
                    <fidl::encoding::Array<
                        fidl::encoding::Optional<
                            fidl::encoding::HandleType<
                                fdomain_client::Vmo,
                                { fidl::ObjectType::VMO.into_raw() },
                                2147483648,
                            >,
                        >,
                        64,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vmos
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.vmo_size),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<BufferFormat, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    >,
                    64,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T3: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<BufferCollectionInfo, 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::<BufferCollectionInfo>(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)?;
            self.2.encode(encoder, offset + 88, depth)?;
            self.3.encode(encoder, offset + 344, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionInfo
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffer_count: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                format: fidl::new_empty!(
                    BufferFormat,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                vmos: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Optional<
                            fidl::encoding::HandleType<
                                fdomain_client::Vmo,
                                { fidl::ObjectType::VMO.into_raw() },
                                2147483648,
                            >,
                        >,
                        64,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                vmo_size: fidl::new_empty!(u64, 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!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffer_count,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                BufferFormat,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.format,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    >,
                    64,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.vmos,
                decoder,
                offset + 88,
                _depth
            )?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.vmo_size,
                decoder,
                offset + 344,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<BufferCollectionInfo2, fdomain_client::fidl::FDomainResourceDialect>
        for &mut BufferCollectionInfo2
    {
        #[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::<BufferCollectionInfo2>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferCollectionInfo2, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_count),
                    <SingleBufferSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),
                    <fidl::encoding::Array<VmoBuffer, 64> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.buffers),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<SingleBufferSettings, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Array<VmoBuffer, 64>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<BufferCollectionInfo2, 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::<BufferCollectionInfo2>(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)?;
            self.2.encode(encoder, offset + 272, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionInfo2
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffer_count: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                settings: fidl::new_empty!(
                    SingleBufferSettings,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                buffers: fidl::new_empty!(fidl::encoding::Array<VmoBuffer, 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!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffer_count,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                SingleBufferSettings,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.settings,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Array<VmoBuffer, 64>, fdomain_client::fidl::FDomainResourceDialect, &mut self.buffers, decoder, offset + 272, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<SingleBufferInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut SingleBufferInfo
    {
        #[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::<SingleBufferInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SingleBufferInfo, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <SingleBufferSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),
                    <VmoBuffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.buffer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<SingleBufferSettings, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<VmoBuffer, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<SingleBufferInfo, 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::<SingleBufferInfo>(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 + 264, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for SingleBufferInfo
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                settings: fidl::new_empty!(
                    SingleBufferSettings,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                buffer: fidl::new_empty!(VmoBuffer, 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!(
                SingleBufferSettings,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.settings,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                VmoBuffer,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.buffer,
                decoder,
                offset + 264,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VmoBuffer {
        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 VmoBuffer {
        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<VmoBuffer, fdomain_client::fidl::FDomainResourceDialect>
        for &mut VmoBuffer
    {
        #[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::<VmoBuffer>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VmoBuffer, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.vmo),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.vmo_usable_start),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<VmoBuffer, 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::<VmoBuffer>(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 VmoBuffer {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                vmo_usable_start: fidl::new_empty!(
                    u64,
                    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::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.vmo,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.vmo_usable_start,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.rights_attenuation_mask
                    .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 BufferCollectionTokenGroupCreateChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<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.token_request.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<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 < 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 =
                    <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.rights_attenuation_mask.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(())
        }
    }
}