fdomain_fuchsia_sysmem2/

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

#[derive(Debug, Default, PartialEq)]
pub struct AllocatorAllocateNonSharedCollectionRequest {
    pub collection_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct AllocatorAllocateSharedCollectionRequest {
    pub token_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct AllocatorBindSharedCollectionRequest {
    pub token: Option<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>,
    pub buffer_collection_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct AllocatorGetVmoInfoRequest {
    /// `vmo` is required to be set; ownership is transferred to the server
    /// so in most cases a client will duplicate a handle and transfer the
    /// duplicate via this field.
    pub vmo: Option<fdomain_client::Vmo>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct AllocatorGetVmoInfoResponse {
    pub buffer_collection_id: Option<u64>,
    pub buffer_index: Option<u64>,
    pub close_weak_asap: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionAttachLifetimeTrackingRequest {
    pub server_end: Option<fdomain_client::EventPair>,
    pub buffers_remaining: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionAttachTokenRequest {
    pub rights_attenuation_mask: Option<fidl::Rights>,
    pub token_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Information about a buffer collection and its buffers.
#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionInfo {
    /// These settings apply to all the buffers in the initial buffer
    /// allocation.
    ///
    /// This field will always be set by sysmem.
    pub settings: Option<SingleBufferSettings>,
    /// VMO handles (and vmo_usable_start offset) for each buffer in the
    /// collection.
    ///
    /// The size of this vector is the buffer_count (buffer_count is not sent
    /// separately).
    ///
    /// 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.
    ///
    /// This field will always have VmoBuffer(s) in it, even if the participant
    /// specifies usage whieh does not require VMO handles.  This permits such a
    /// participant to know the vmo_usable_start values, in case that's of any
    /// use to the participant.
    ///
    /// This field will always be set by sysmem, even if the participant doesn't
    /// specify any buffer usage (but the [`fuchsia.sysmem2/VmoBuffer.vmo`]
    /// sub-field within this field won't be set in that case).
    pub buffers: Option<Vec<VmoBuffer>>,
    /// This number is unique among all logical buffer collections per boot.
    ///
    /// This ID number will be the same for all BufferCollectionToken(s),
    /// BufferCollection(s), and BufferCollectionTokenGroup(s) associated with
    /// the same logical buffer collection (derived from the same root token
    /// created with fuchsia.sysmem2.Allocator.CreateSharedCollection, or with
    /// CreateNonSharedCollection).
    ///
    /// The same ID can be retrieved from a BufferCollectionToken,
    /// BufferCollection, or BufferCollectionTokenGroup using
    /// GetBufferCollectionId (at the cost of a round-trip to sysmem and back).
    ///
    /// This field will always be set by sysmem.
    pub buffer_collection_id: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionSetConstraintsRequest {
    pub constraints: Option<BufferCollectionConstraints>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionTokenCreateBufferCollectionTokenGroupRequest {
    pub group_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionTokenDuplicateRequest {
    pub rights_attenuation_mask: Option<fidl::Rights>,
    pub token_request: Option<fdomain_client::fidl::ServerEnd<BufferCollectionTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[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<fidl::Rights>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionTokenGroupCreateChildrenSyncResponse {
    pub tokens: Option<Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionTokenDuplicateSyncResponse {
    pub tokens: Option<Vec<fdomain_client::fidl::ClientEnd<BufferCollectionTokenMarker>>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct BufferCollectionWaitForAllBuffersAllocatedResponse {
    pub buffer_collection_info: Option<BufferCollectionInfo>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct NodeAttachNodeTrackingRequest {
    /// This field must be set. This evenpair end will be closed after the
    /// `Node` is closed or failed and the node's buffer counts are no
    /// longer in effect in the logical buffer collection.
    pub server_end: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct NodeIsAlternateForRequest {
    pub node_ref: Option<fdomain_client::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct NodeSetWeakOkRequest {
    pub for_child_nodes_also: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct NodeGetNodeRefResponse {
    pub node_ref: Option<fdomain_client::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct VmoBuffer {
    /// `vmo` can be un-set if a participant has only
    /// [`fuchsia.sysmem2/BufferUsage.none`] set to `NONE_USAGE` (explicitly or
    /// implicitly by [`fuchsia.sysmem2/BufferCollection.SetConstraints`]
    /// without `constraints` set).
    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.
    ///
    /// Currently sysmem will always set this field to 0, and in future, sysmem
    /// won't set this field to a non-zero value unless all participants have
    /// explicitly indicated support for non-zero vmo_usable_start (this
    /// mechanism does not exist as of this comment). A participant that hasn't
    /// explicitly indicated support for non-zero vmo_usable_start (all current
    /// clients) should implicitly assume this field is set to 0 without
    /// actually checking this field.
    pub vmo_usable_start: Option<u64>,
    /// This field is set iff `vmo` is a sysmem weak VMO handle.
    ///
    /// If the client sent `SetWeakOk`, the client must keep `close_weak_asap`
    /// around for as long as `vmo`, and must notice `ZX_EVENTPAIR_PEER_CLOSED`.
    /// If that signal occurs, the client must close `vmo` asap.
    ///
    /// If the `vmo` is a sysmem weak VMO handle but the client didn't send
    /// `SetWeakOk`, this means that a holder of a parent node sent `SetWeakOk`
    /// with `for_child_nodes_also` true, and the owner of that parent node is
    /// responsible for paying attention to `close_weak_asap` and informing
    /// child token participants to close handles. In this case the participant
    /// that never sent `SetWeakOk` is allowed to retain and/or pay attention to
    /// `close_weak_asap` (to close the handle faster, or for other reasons such
    /// as diagnosing overall buffer cleanup timing), but is not required to
    /// retain or pay attention to `close_weak_asap`.
    ///
    /// If sysmem closing the sysmem end of `close_weak_asap` does not result in
    /// quick closure of all sysmem weak VMO handles to the buffer, that's
    /// considered a VMO leak, and in that case sysmem will eventually complain
    /// loudly via syslog (currently 5s later).
    pub close_weak_asap: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[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.sysmem2.Allocator";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for AllocatorMarker {}
pub type AllocatorGetVmoInfoResult = Result<AllocatorGetVmoInfoResponse, Error>;

pub trait AllocatorProxyInterface: Send + Sync {
    fn r#allocate_non_shared_collection(
        &self,
        payload: AllocatorAllocateNonSharedCollectionRequest,
    ) -> Result<(), fidl::Error>;
    fn r#allocate_shared_collection(
        &self,
        payload: AllocatorAllocateSharedCollectionRequest,
    ) -> Result<(), fidl::Error>;
    fn r#bind_shared_collection(
        &self,
        payload: AllocatorBindSharedCollectionRequest,
    ) -> Result<(), fidl::Error>;
    type ValidateBufferCollectionTokenResponseFut: std::future::Future<
            Output = Result<AllocatorValidateBufferCollectionTokenResponse, fidl::Error>,
        > + Send;
    fn r#validate_buffer_collection_token(
        &self,
        payload: &AllocatorValidateBufferCollectionTokenRequest,
    ) -> Self::ValidateBufferCollectionTokenResponseFut;
    fn r#set_debug_client_info(
        &self,
        payload: &AllocatorSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error>;
    type GetVmoInfoResponseFut: std::future::Future<Output = Result<AllocatorGetVmoInfoResult, fidl::Error>>
        + Send;
    fn r#get_vmo_info(&self, payload: AllocatorGetVmoInfoRequest) -> Self::GetVmoInfoResponseFut;
}

#[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.sysmem2/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 buffer collection 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
    /// [`fuchsia.sysmem2/BufferCollectionToken`] stage, so there's no way to
    /// allow another participant to specify its constraints.
    ///
    /// Real clients are encouraged to use
    /// [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`] instead, and to
    /// let relevant participants directly convey their own constraints to
    /// sysmem by sending `BufferCollectionToken`s to those participants.
    ///
    /// + request `collection_request` The server end of the
    ///   [`fuchsia.sysmem2/BufferCollection`].
    pub fn r#allocate_non_shared_collection(
        &self,
        mut payload: AllocatorAllocateNonSharedCollectionRequest,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#allocate_non_shared_collection(self, payload)
    }

    /// Creates a root [`fuchsia.sysmem2/BufferCollectionToken`].
    ///
    /// The `BufferCollectionToken` can be "duplicated" for distribution to
    /// participants by using
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`]. Each
    /// `BufferCollectionToken` can be converted into a
    /// [`fuchsia.sysmem2.BufferCollection`] using
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`].
    ///
    /// Buffer constraints can be set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// Success/failure to populate the buffer collection with buffers can be
    /// determined from
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// Closing the client end of a `BufferCollectionToken` or
    /// `BufferCollection` (without `Release` first) will fail all client ends
    /// in the same failure domain, which by default is all client ends of the
    /// buffer collection. See
    /// [`fuchsia.sysmem2/BufferCollection.SetDispensable`] and
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`] for ways to create
    /// separate failure domains within a buffer collection.
    pub fn r#allocate_shared_collection(
        &self,
        mut payload: AllocatorAllocateSharedCollectionRequest,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#allocate_shared_collection(self, payload)
    }

    /// Convert a [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// At the time of sending this message, the buffer collection hasn't yet
    /// been populated with buffers - the participant must first also send
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] via the
    /// `BufferCollection` client end.
    ///
    /// All `BufferCollectionToken`(s) duplicated from a root
    /// `BufferCollectionToken` (created via `AllocateSharedCollection`) must be
    /// "turned in" via `BindSharedCollection` (or `Release`ed), and all
    /// existing `BufferCollection` client ends must have sent `SetConstraints`
    /// before the logical BufferCollection will be populated with buffers (or
    /// will fail if the overall set of constraints can't be satisfied).
    ///
    /// + request `token` The client endpoint of a channel whose server end was
    ///   sent to sysmem using
    ///   [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`] or whose server
    ///   end was sent to sysmem using
    ///   [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`].  The token is
    ///   being "turned in" in exchange for a
    ///   [`fuchsia.sysmem2/BufferCollection`].
    /// + request `buffer_collection_request` The server end of a
    ///   [`fuchsia.sysmem2/BufferCollection`] channel.  The sender retains the
    ///   client end. The `BufferCollection` channel is a single participant's
    ///   connection to the logical buffer collection. Typically there will be
    ///   other participants with their own `BufferCollection` channel to the
    ///   logical buffer collection.
    pub fn r#bind_shared_collection(
        &self,
        mut payload: AllocatorBindSharedCollectionRequest,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#bind_shared_collection(self, payload)
    }

    /// Checks whether a [`fuchsia.sysmem2/BufferCollectionToken`] is known to
    /// the sysmem server.
    ///
    /// With this call, the client can determine whether an incoming token is a
    /// real sysmem token that is known to the sysmem server, without any risk
    /// of getting stuck waiting forever on a potentially fake token to complete
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] or
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] (or any other two-way
    /// FIDL message). In cases where the client trusts the source of the token
    /// to provide a real token, this call is not typically needed outside of
    /// debugging.
    ///
    /// If the validate fails sometimes but succeeds other times, the source of
    /// the token may itself not be calling
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] or
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after creating/duplicating the
    /// token but before sending the token to the current client. It may be more
    /// convenient for the source to use
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] to duplicate
    /// token(s), since that call has the sync step built in. Or, the buffer
    /// collection may be failing before this call is processed by the sysmem
    /// server, as buffer collection failure cleans up sysmem's tracking of
    /// associated tokens.
    ///
    /// This call has no effect on any token.
    ///
    /// + request `token_server_koid` The koid of the server end of a channel
    ///   that might be a BufferCollectionToken channel.  This can be obtained
    ///   via `zx_object_get_info` `ZX_INFO_HANDLE_BASIC` `related_koid`.
    /// - response `is_known` true means sysmem knew of the token at the time
    ///   sysmem processed the request, but doesn't guarantee that the token is
    ///   still valid by the time the client receives the reply. What it does
    ///   guarantee is that the token at least was a real token, so a two-way
    ///   call to the token won't stall forever (will fail or succeed fairly
    ///   quickly, not stall). This can already be known implicitly if the
    ///   source of the token can be trusted to provide a real token. A false
    ///   value means the token wasn't known to sysmem at the time sysmem
    ///   processed this call, but the token may have previously been valid, or
    ///   may yet become valid. Or if the sender of the token isn't trusted to
    ///   provide a real token, the token may be fake. It's the responsibility
    ///   of the sender to sync with sysmem to ensure that previously
    ///   created/duplicated token(s) are known to sysmem, before sending the
    ///   token(s) to other participants.
    pub fn r#validate_buffer_collection_token(
        &self,
        mut payload: &AllocatorValidateBufferCollectionTokenRequest,
    ) -> fidl::client::QueryResponseFut<
        AllocatorValidateBufferCollectionTokenResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        AllocatorProxyInterface::r#validate_buffer_collection_token(self, payload)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on all [`fuchsia.sysmem2/Node`](s)
    /// subsequently created by this this [`fuchsia.sysmem2/Allocator`]
    /// including any [`fuchsia.sysmem2/BufferCollection`](s) created via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] (in the absence of
    /// any prior call to [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`],
    /// these `BufferCollection`(s) have the same initial debug client info as
    /// the token turned in to create the `BufferCollection`).
    ///
    /// This info can be subsequently overridden on a per-`Node` basis by
    /// sending [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    pub fn r#set_debug_client_info(
        &self,
        mut payload: &AllocatorSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error> {
        AllocatorProxyInterface::r#set_debug_client_info(self, payload)
    }

    /// Given a handle to a sysmem-provided VMO, this returns additional info
    /// about the corresponding sysmem logical buffer.
    ///
    /// Most callers will duplicate a VMO handle first and send the duplicate to
    /// this call.
    ///
    /// If the client has created a child VMO of a sysmem-provided VMO, that
    /// child VMO isn't considered a "sysmem VMO" for purposes of this call.
    ///
    /// + request `vmo` A handle to a sysmem-provided VMO (or see errors).
    /// - response `buffer_collection_id` The buffer collection ID, which is
    ///   unique per logical buffer collection per boot.
    /// - response `buffer_index` The buffer index of the buffer within the
    ///   buffer collection. This is the same as the index of the buffer within
    ///   [`fuchsia.sysmem2/BufferCollectionInfo.buffers`]. The `buffer_index`
    ///   is the same for all sysmem-delivered VMOs corresponding to the same
    ///   logical buffer, even if the VMO koids differ. The `buffer_index` is
    ///   only unique across buffers of a buffer collection. For a given buffer,
    ///   the combination of `buffer_collection_id` and `buffer_index` is unique
    ///   per boot.
    /// - response `close_weak_asap` Iff `vmo` is a handle to a weak sysmem VMO,
    ///   the `close_weak_asap` field will be set in the response. This handle
    ///   will signal `ZX_EVENTPAIR_PEER_CLOSED` when all weak VMO handles to
    ///   the buffer should be closed as soon as possible. This is signalled
    ///   shortly after all strong sysmem VMOs to the buffer are closed
    ///   (including any held indirectly via strong `BufferCollectionToken` or
    ///   strong `BufferCollection`). Failure to close all weak sysmem VMO
    ///   handles to the buffer quickly upon `ZX_EVENTPAIR_PEER_CLOSED` is
    ///   considered a VMO leak caused by the client still holding a weak sysmem
    ///   VMO handle and results in loud complaints to the log by sysmem. The
    ///   buffers of a collection can be freed independently of each other. The
    ///   `ZX_EVENTPAIR_PEER_CLOSED` may already be signalled before the
    ///   response arrives at the client. A client that isn't prepared to handle
    ///   weak sysmem VMOs, on seeing this field set, can close all handles to
    ///   the buffer and fail any associated request.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` - the vmo isn't a sysmem
    ///   VMO. Both strong and weak sysmem VMOs can be passed to this call, and
    ///   the VMO handle passed in to this call itself keeps the VMO's info
    ///   alive for purposes of responding to this call. Because of this,
    ///   ZX_ERR_NOT_FOUND errors are unambiguous (even if there are no other
    ///   handles to the VMO when calling; even if other handles are closed
    ///   before the GetVmoInfo response arrives at the client).
    /// * error `[fuchsia.sysmem2/Error.HANDLE_ACCESS_DENIED]` The vmo isn't
    ///   capable of being used with GetVmoInfo due to rights/capability
    ///   attenuation. The VMO needs to be usable with [`zx_vmo_get_info`] with
    ///   topic [`ZX_INFO_HANDLE_BASIC`].
    /// * error `[fuchsia.sysmem2/Error.UNSPECIFIED]` The request failed for an
    ///   unspecified reason. See the log for more info.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The vmo field
    ///   wasn't set, or there was some other problem with the request field(s).
    pub fn r#get_vmo_info(
        &self,
        mut payload: AllocatorGetVmoInfoRequest,
    ) -> fidl::client::QueryResponseFut<
        AllocatorGetVmoInfoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        AllocatorProxyInterface::r#get_vmo_info(self, payload)
    }
}

impl AllocatorProxyInterface for AllocatorProxy {
    fn r#allocate_non_shared_collection(
        &self,
        mut payload: AllocatorAllocateNonSharedCollectionRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AllocatorAllocateNonSharedCollectionRequest>(
            &mut payload,
            0x5ca681f025a80e44,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

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

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

    type ValidateBufferCollectionTokenResponseFut = fidl::client::QueryResponseFut<
        AllocatorValidateBufferCollectionTokenResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#validate_buffer_collection_token(
        &self,
        mut payload: &AllocatorValidateBufferCollectionTokenRequest,
    ) -> Self::ValidateBufferCollectionTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AllocatorValidateBufferCollectionTokenResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AllocatorValidateBufferCollectionTokenResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4c5ee91b02a7e68d,
            >(_buf?)?
            .into_result_fdomain::<AllocatorMarker>("validate_buffer_collection_token")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            AllocatorValidateBufferCollectionTokenRequest,
            AllocatorValidateBufferCollectionTokenResponse,
        >(
            payload,
            0x4c5ee91b02a7e68d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

    type GetVmoInfoResponseFut = fidl::client::QueryResponseFut<
        AllocatorGetVmoInfoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_vmo_info(
        &self,
        mut payload: AllocatorGetVmoInfoRequest,
    ) -> Self::GetVmoInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AllocatorGetVmoInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<AllocatorGetVmoInfoResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x21a881120aa0ddf9,
            >(_buf?)?
            .into_result_fdomain::<AllocatorMarker>("get_vmo_info")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AllocatorGetVmoInfoRequest, AllocatorGetVmoInfoResult>(
            &mut payload,
            0x21a881120aa0ddf9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(AllocatorEvent::_UnknownEvent { ordinal: 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.sysmem2/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 {
                    0x5ca681f025a80e44 => {
                        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 {
                            payload: req,
                            control_handle,
                        })
                    }
                    0x11a19ff51f0b49c1 => {
                        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 {
                            payload: req,
                            control_handle,
                        })
                    }
                    0x550916b0dc1d5b4e => {
                        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 { payload: req, control_handle })
                    }
                    0x4c5ee91b02a7e68d => {
                        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 {
                            payload: req,
                            responder: AllocatorValidateBufferCollectionTokenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f68f19a3f509c4d => {
                        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 { payload: req, control_handle })
                    }
                    0x21a881120aa0ddf9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorGetVmoInfoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AllocatorGetVmoInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::GetVmoInfo {
                            payload: req,
                            responder: AllocatorGetVmoInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AllocatorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AllocatorControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(AllocatorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AllocatorControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AllocatorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Allocates system memory buffers.
///
/// Epitaphs are not used in this protocol.
#[derive(Debug)]
pub enum AllocatorRequest {
    /// Allocates a buffer collection 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
    /// [`fuchsia.sysmem2/BufferCollectionToken`] stage, so there's no way to
    /// allow another participant to specify its constraints.
    ///
    /// Real clients are encouraged to use
    /// [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`] instead, and to
    /// let relevant participants directly convey their own constraints to
    /// sysmem by sending `BufferCollectionToken`s to those participants.
    ///
    /// + request `collection_request` The server end of the
    ///   [`fuchsia.sysmem2/BufferCollection`].
    AllocateNonSharedCollection {
        payload: AllocatorAllocateNonSharedCollectionRequest,
        control_handle: AllocatorControlHandle,
    },
    /// Creates a root [`fuchsia.sysmem2/BufferCollectionToken`].
    ///
    /// The `BufferCollectionToken` can be "duplicated" for distribution to
    /// participants by using
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`]. Each
    /// `BufferCollectionToken` can be converted into a
    /// [`fuchsia.sysmem2.BufferCollection`] using
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`].
    ///
    /// Buffer constraints can be set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// Success/failure to populate the buffer collection with buffers can be
    /// determined from
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// Closing the client end of a `BufferCollectionToken` or
    /// `BufferCollection` (without `Release` first) will fail all client ends
    /// in the same failure domain, which by default is all client ends of the
    /// buffer collection. See
    /// [`fuchsia.sysmem2/BufferCollection.SetDispensable`] and
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`] for ways to create
    /// separate failure domains within a buffer collection.
    AllocateSharedCollection {
        payload: AllocatorAllocateSharedCollectionRequest,
        control_handle: AllocatorControlHandle,
    },
    /// Convert a [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// At the time of sending this message, the buffer collection hasn't yet
    /// been populated with buffers - the participant must first also send
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] via the
    /// `BufferCollection` client end.
    ///
    /// All `BufferCollectionToken`(s) duplicated from a root
    /// `BufferCollectionToken` (created via `AllocateSharedCollection`) must be
    /// "turned in" via `BindSharedCollection` (or `Release`ed), and all
    /// existing `BufferCollection` client ends must have sent `SetConstraints`
    /// before the logical BufferCollection will be populated with buffers (or
    /// will fail if the overall set of constraints can't be satisfied).
    ///
    /// + request `token` The client endpoint of a channel whose server end was
    ///   sent to sysmem using
    ///   [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`] or whose server
    ///   end was sent to sysmem using
    ///   [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`].  The token is
    ///   being "turned in" in exchange for a
    ///   [`fuchsia.sysmem2/BufferCollection`].
    /// + request `buffer_collection_request` The server end of a
    ///   [`fuchsia.sysmem2/BufferCollection`] channel.  The sender retains the
    ///   client end. The `BufferCollection` channel is a single participant's
    ///   connection to the logical buffer collection. Typically there will be
    ///   other participants with their own `BufferCollection` channel to the
    ///   logical buffer collection.
    BindSharedCollection {
        payload: AllocatorBindSharedCollectionRequest,
        control_handle: AllocatorControlHandle,
    },
    /// Checks whether a [`fuchsia.sysmem2/BufferCollectionToken`] is known to
    /// the sysmem server.
    ///
    /// With this call, the client can determine whether an incoming token is a
    /// real sysmem token that is known to the sysmem server, without any risk
    /// of getting stuck waiting forever on a potentially fake token to complete
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] or
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] (or any other two-way
    /// FIDL message). In cases where the client trusts the source of the token
    /// to provide a real token, this call is not typically needed outside of
    /// debugging.
    ///
    /// If the validate fails sometimes but succeeds other times, the source of
    /// the token may itself not be calling
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] or
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after creating/duplicating the
    /// token but before sending the token to the current client. It may be more
    /// convenient for the source to use
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] to duplicate
    /// token(s), since that call has the sync step built in. Or, the buffer
    /// collection may be failing before this call is processed by the sysmem
    /// server, as buffer collection failure cleans up sysmem's tracking of
    /// associated tokens.
    ///
    /// This call has no effect on any token.
    ///
    /// + request `token_server_koid` The koid of the server end of a channel
    ///   that might be a BufferCollectionToken channel.  This can be obtained
    ///   via `zx_object_get_info` `ZX_INFO_HANDLE_BASIC` `related_koid`.
    /// - response `is_known` true means sysmem knew of the token at the time
    ///   sysmem processed the request, but doesn't guarantee that the token is
    ///   still valid by the time the client receives the reply. What it does
    ///   guarantee is that the token at least was a real token, so a two-way
    ///   call to the token won't stall forever (will fail or succeed fairly
    ///   quickly, not stall). This can already be known implicitly if the
    ///   source of the token can be trusted to provide a real token. A false
    ///   value means the token wasn't known to sysmem at the time sysmem
    ///   processed this call, but the token may have previously been valid, or
    ///   may yet become valid. Or if the sender of the token isn't trusted to
    ///   provide a real token, the token may be fake. It's the responsibility
    ///   of the sender to sync with sysmem to ensure that previously
    ///   created/duplicated token(s) are known to sysmem, before sending the
    ///   token(s) to other participants.
    ValidateBufferCollectionToken {
        payload: AllocatorValidateBufferCollectionTokenRequest,
        responder: AllocatorValidateBufferCollectionTokenResponder,
    },
    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on all [`fuchsia.sysmem2/Node`](s)
    /// subsequently created by this this [`fuchsia.sysmem2/Allocator`]
    /// including any [`fuchsia.sysmem2/BufferCollection`](s) created via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] (in the absence of
    /// any prior call to [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`],
    /// these `BufferCollection`(s) have the same initial debug client info as
    /// the token turned in to create the `BufferCollection`).
    ///
    /// This info can be subsequently overridden on a per-`Node` basis by
    /// sending [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    SetDebugClientInfo {
        payload: AllocatorSetDebugClientInfoRequest,
        control_handle: AllocatorControlHandle,
    },
    /// Given a handle to a sysmem-provided VMO, this returns additional info
    /// about the corresponding sysmem logical buffer.
    ///
    /// Most callers will duplicate a VMO handle first and send the duplicate to
    /// this call.
    ///
    /// If the client has created a child VMO of a sysmem-provided VMO, that
    /// child VMO isn't considered a "sysmem VMO" for purposes of this call.
    ///
    /// + request `vmo` A handle to a sysmem-provided VMO (or see errors).
    /// - response `buffer_collection_id` The buffer collection ID, which is
    ///   unique per logical buffer collection per boot.
    /// - response `buffer_index` The buffer index of the buffer within the
    ///   buffer collection. This is the same as the index of the buffer within
    ///   [`fuchsia.sysmem2/BufferCollectionInfo.buffers`]. The `buffer_index`
    ///   is the same for all sysmem-delivered VMOs corresponding to the same
    ///   logical buffer, even if the VMO koids differ. The `buffer_index` is
    ///   only unique across buffers of a buffer collection. For a given buffer,
    ///   the combination of `buffer_collection_id` and `buffer_index` is unique
    ///   per boot.
    /// - response `close_weak_asap` Iff `vmo` is a handle to a weak sysmem VMO,
    ///   the `close_weak_asap` field will be set in the response. This handle
    ///   will signal `ZX_EVENTPAIR_PEER_CLOSED` when all weak VMO handles to
    ///   the buffer should be closed as soon as possible. This is signalled
    ///   shortly after all strong sysmem VMOs to the buffer are closed
    ///   (including any held indirectly via strong `BufferCollectionToken` or
    ///   strong `BufferCollection`). Failure to close all weak sysmem VMO
    ///   handles to the buffer quickly upon `ZX_EVENTPAIR_PEER_CLOSED` is
    ///   considered a VMO leak caused by the client still holding a weak sysmem
    ///   VMO handle and results in loud complaints to the log by sysmem. The
    ///   buffers of a collection can be freed independently of each other. The
    ///   `ZX_EVENTPAIR_PEER_CLOSED` may already be signalled before the
    ///   response arrives at the client. A client that isn't prepared to handle
    ///   weak sysmem VMOs, on seeing this field set, can close all handles to
    ///   the buffer and fail any associated request.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` - the vmo isn't a sysmem
    ///   VMO. Both strong and weak sysmem VMOs can be passed to this call, and
    ///   the VMO handle passed in to this call itself keeps the VMO's info
    ///   alive for purposes of responding to this call. Because of this,
    ///   ZX_ERR_NOT_FOUND errors are unambiguous (even if there are no other
    ///   handles to the VMO when calling; even if other handles are closed
    ///   before the GetVmoInfo response arrives at the client).
    /// * error `[fuchsia.sysmem2/Error.HANDLE_ACCESS_DENIED]` The vmo isn't
    ///   capable of being used with GetVmoInfo due to rights/capability
    ///   attenuation. The VMO needs to be usable with [`zx_vmo_get_info`] with
    ///   topic [`ZX_INFO_HANDLE_BASIC`].
    /// * error `[fuchsia.sysmem2/Error.UNSPECIFIED]` The request failed for an
    ///   unspecified reason. See the log for more info.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The vmo field
    ///   wasn't set, or there was some other problem with the request field(s).
    GetVmoInfo { payload: AllocatorGetVmoInfoRequest, responder: AllocatorGetVmoInfoResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: AllocatorControlHandle,
        method_type: fidl::MethodType,
    },
}

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_shared_collection(
        self,
    ) -> Option<(AllocatorBindSharedCollectionRequest, AllocatorControlHandle)> {
        if let AllocatorRequest::BindSharedCollection { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo_info(
        self,
    ) -> Option<(AllocatorGetVmoInfoRequest, AllocatorGetVmoInfoResponder)> {
        if let AllocatorRequest::GetVmoInfo { payload, responder } = self {
            Some((payload, responder))
        } 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::GetVmoInfo { .. } => "get_vmo_info",
            AllocatorRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            AllocatorRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct AllocatorGetVmoInfoResponder {
    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 AllocatorGetVmoInfoResponder {
    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 AllocatorGetVmoInfoResponder {
    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 AllocatorGetVmoInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<AllocatorGetVmoInfoResponse, Error>,
    ) -> 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<AllocatorGetVmoInfoResponse, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

#[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 type BufferCollectionWaitForAllBuffersAllocatedResult =
    Result<BufferCollectionWaitForAllBuffersAllocatedResponse, Error>;
pub type BufferCollectionCheckAllBuffersAllocatedResult = Result<(), Error>;

pub trait BufferCollectionProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#release(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, payload: &NodeSetNameRequest) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(
        &self,
        payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(
        &self,
        payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<NodeGetNodeRefResponse, 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,
        payload: NodeIsAlternateForRequest,
    ) -> Self::IsAlternateForResponseFut;
    type GetBufferCollectionIdResponseFut: std::future::Future<Output = Result<NodeGetBufferCollectionIdResponse, fidl::Error>>
        + Send;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut;
    fn r#set_weak(&self) -> Result<(), fidl::Error>;
    fn r#set_weak_ok(&self, payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error>;
    fn r#attach_node_tracking(
        &self,
        payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_constraints(
        &self,
        payload: BufferCollectionSetConstraintsRequest,
    ) -> Result<(), fidl::Error>;
    type WaitForAllBuffersAllocatedResponseFut: std::future::Future<
            Output = Result<BufferCollectionWaitForAllBuffersAllocatedResult, fidl::Error>,
        > + Send;
    fn r#wait_for_all_buffers_allocated(&self) -> Self::WaitForAllBuffersAllocatedResponseFut;
    type CheckAllBuffersAllocatedResponseFut: std::future::Future<
            Output = Result<BufferCollectionCheckAllBuffersAllocatedResult, fidl::Error>,
        > + Send;
    fn r#check_all_buffers_allocated(&self) -> Self::CheckAllBuffersAllocatedResponseFut;
    fn r#attach_token(
        &self,
        payload: BufferCollectionAttachTokenRequest,
    ) -> Result<(), fidl::Error>;
    fn r#attach_lifetime_tracking(
        &self,
        payload: BufferCollectionAttachLifetimeTrackingRequest,
    ) -> 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.sysmem2/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 have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionProxyInterface::r#sync(self)
    }

    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    pub fn r#release(&self) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#release(self)
    }

    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    pub fn r#set_name(&self, mut payload: &NodeSetNameRequest) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_name(self, payload)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    pub fn r#set_debug_client_info(
        &self,
        mut payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_debug_client_info(self, payload)
    }

    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    pub fn r#set_debug_timeout_log_deadline(
        &self,
        mut payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_debug_timeout_log_deadline(self, payload)
    }

    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#get_node_ref(self)
    }

    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    pub fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#is_alternate_for(self, payload)
    }

    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    pub fn r#get_buffer_collection_id(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#get_buffer_collection_id(self)
    }

    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    pub fn r#set_weak(&self) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_weak(self)
    }

    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    pub fn r#set_weak_ok(&self, mut payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_weak_ok(self, payload)
    }

    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    pub fn r#attach_node_tracking(
        &self,
        mut payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#attach_node_tracking(self, payload)
    }

    /// Provide [`fuchsia.sysmem2/BufferCollectionConstraints`] to the buffer
    /// collection.
    ///
    /// A participant may only call
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] up to once per
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// For buffer allocation to be attempted, all holders of a
    /// `BufferCollection` client end need to call `SetConstraints` before
    /// sysmem will attempt to allocate buffers.
    ///
    /// + request `constraints` These are the constraints on the buffer
    ///   collection imposed by the sending client/participant.  The
    ///   `constraints` field is not required to be set. If not set, the client
    ///   is not setting any actual constraints, but is indicating that the
    ///   client has no constraints to set. A client that doesn't set the
    ///   `constraints` field won't receive any VMO handles, but can still find
    ///   out how many buffers were allocated and can still refer to buffers by
    ///   their `buffer_index`.
    pub fn r#set_constraints(
        &self,
        mut payload: BufferCollectionSetConstraintsRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#set_constraints(self, payload)
    }

    /// Wait until all buffers are allocated.
    ///
    /// This FIDL call completes when buffers have been allocated, or completes
    /// with some failure detail if allocation has been attempted but failed.
    ///
    /// The following must occur before buffers will be allocated:
    ///   * All [`fuchsia.sysmem2/BufferCollectionToken`](s) of the buffer
    ///     collection must be turned in via `BindSharedCollection` to get a
    ///     [`fuchsia.sysmem2/BufferCollection`] (for brevity, this is assuming
    ///     [`fuchsia.sysmem2/BufferCollection.AttachToken`] isn't being used),
    ///     or have had [`fuchsia.sysmem2/BufferCollectionToken.Release`] sent
    ///     to them.
    ///   * All [`fuchsia.sysmem2/BufferCollection`](s) of the buffer collection
    ///     must have had [`fuchsia.sysmem2/BufferCollection.SetConstraints`]
    ///     sent to them, or had [`fuchsia.sysmem2/BufferCollection.Release`]
    ///     sent to them.
    ///
    /// - result `buffer_collection_info` The VMO handles and other related
    ///   info.
    /// * error `[fuchsia.sysmem2/Error.NO_MEMORY]` The request is valid but
    ///   cannot be fulfilled due to resource exhaustion.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION`] The request is
    ///   malformed.
    /// * error `[fuchsia.sysmem2/Error.CONSTRAINTS_INTERSECTION_EMPTY`] The
    ///   request is valid but cannot be satisfied, perhaps due to hardware
    ///   limitations. This can happen if participants have incompatible
    ///   constraints (empty intersection, roughly speaking). See the log for
    ///   more info. In cases where a participant could potentially be treated
    ///   as optional, see [`BufferCollectionTokenGroup`]. When using
    ///   [`fuchsia.sysmem2/BufferCollection.AttachToken`], this will be the
    ///   error code if there aren't enough buffers in the pre-existing
    ///   collection to satisfy the constraints set on the attached token and
    ///   any sub-tree of tokens derived from the attached token.
    pub fn r#wait_for_all_buffers_allocated(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BufferCollectionWaitForAllBuffersAllocatedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#wait_for_all_buffers_allocated(self)
    }

    /// Checks whether all the buffers have been allocated, in a polling
    /// fashion.
    ///
    /// * If the buffer collection has been allocated, returns success.
    /// * If the buffer collection failed allocation, returns the same
    ///   [`fuchsia.sysmem2/Error`] as
    ///   [`fuchsia.sysmem2/BufferCollection/WaitForAllBuffersAllocated`] would
    ///   return.
    /// * error [`fuchsia.sysmem2/Error.PENDING`] The buffer collection hasn't
    ///   attempted allocation yet. This means that WaitForAllBuffersAllocated
    ///   would not respond quickly.
    pub fn r#check_all_buffers_allocated(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BufferCollectionCheckAllBuffersAllocatedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionProxyInterface::r#check_all_buffers_allocated(self)
    }

    /// Create a new token to add a new participant to an existing logical
    /// buffer 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.
    ///
    /// When [`fuchsia.sysmem2/BufferCollection.AttachToken`] is used, the sub
    /// tree rooted at the attached [`fuchsia.sysmem2/BufferCollectionToken`]
    /// goes through the normal procedure of setting constraints or closing
    /// [`fuchsia.sysmem2/Node`](s), and then appearing to allocate buffers from
    /// clients' point of view, despite the possibility that all the buffers
    /// were actually allocated previously. This process is called "logical
    /// allocation". Most instances of "allocation" in docs for other messages
    /// can also be read as "allocation or logical allocation" while remaining
    /// valid, but we just say "allocation" in most places for brevity/clarity
    /// of explanation, with the details of "logical allocation" left for the
    /// docs here on `AttachToken`.
    ///
    /// Failure of an attached `Node` does not propagate to the parent of the
    /// attached `Node`. More generally, failure of a child `Node` is blocked
    /// from reaching its parent `Node` if the child is attached, or if the
    /// child is dispensable and the failure occurred after logical allocation
    /// (see [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`]).
    ///
    /// A participant may in some scenarios choose to initially use a
    /// dispensable token for a given instance of a delegate participant, and
    /// then later if the first instance of that delegate participant fails, a
    /// new second instance of that delegate participant my be given a token
    /// created with `AttachToken`.
    ///
    /// From the point of view of the [`fuchsia.sysmem2/BufferCollectionToken`]
    /// client end, the token acts like any other token. The client can
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] the token as needed,
    /// and can send the token to a different process/participant. The
    /// `BufferCollectionToken` `Node` should be converted to a
    /// `BufferCollection` `Node` as normal by sending
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or can be closed
    /// without causing subtree failure by sending
    /// [`fuchsia.sysmem2/BufferCollectionToken.Release`]. Assuming the former,
    /// the [`fuchsia.sysmem2/BufferCollection.SetConstraints`] message or
    /// [`fuchsia.sysmem2/BufferCollection.Release`] message should be sent to
    /// the `BufferCollection`.
    ///
    /// Within the subtree, a success result from
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`] means
    /// the subtree participants' constraints were satisfiable using the
    /// already-existing buffer collection, the already-established
    /// [`fuchsia.sysmem2/BufferCollectionInfo`] including image format
    /// constraints, and the already-existing other participants (already added
    /// via successful logical allocation) and their specified buffer counts in
    /// their constraints. A failure result means the new participants'
    /// constraints cannot be satisfied using the existing buffer collection and
    /// its already-added participants. Creating a new collection instead may
    /// allow all participants' 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.
    /// Further subtrees under this subtree are considered for logical
    /// allocation only after this subtree has completed logical allocation.
    ///
    /// Assignment of existing buffers to participants'
    /// [`fuchsia.sysmem2/BufferCollectionConstraints.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 [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`], which
    /// in contrast to `AttachToken`, has the created token `Node` + child
    /// `Node`(s) (in the created subtree but not in any subtree under this
    /// subtree) participate in constraints aggregation along with its parent
    /// during the parent's allocation or logical allocation.
    ///
    /// Similar to [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`], the
    /// newly created token needs to be [`fuchsia.sysmem2/Node.Sync`]ed to
    /// sysmem before the new token can be passed to `BindSharedCollection`. The
    /// `Sync` of the new token can be accomplished with
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after converting the created
    /// `BufferCollectionToken` to a `BufferCollection`. Alternately,
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on the new token also
    /// works. Or using [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`]
    /// works. As usual, 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.
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attentuation_mask` This allows attenuating the VMO
    ///   rights of the subtree. These values for `rights_attenuation_mask`
    ///   result in no attenuation (note that 0 is not on this list):
    ///   + ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   + 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    /// + request `token_request` The server end of the `BufferCollectionToken`
    ///   channel. The client retains the client end.
    pub fn r#attach_token(
        &self,
        mut payload: BufferCollectionAttachTokenRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#attach_token(self, payload)
    }

    /// Set up an eventpair to be signalled (`ZX_EVENTPAIR_PEER_CLOSED`) when
    /// buffers have been allocated and only the specified number of buffers (or
    /// fewer) remain in the buffer collection.
    ///
    /// [`fuchsia.sysmem2/BufferCollection.AttachLifetimeTracking`] allows a
    /// client to wait until an old buffer collection is fully or mostly
    /// deallocated before attempting allocation of a new buffer collection. The
    /// eventpair is only signalled when the buffers of this collection have
    /// been fully deallocated (not just un-referenced by clients, but all the
    /// memory consumed by those buffers has been fully reclaimed/recycled), or
    /// when allocation or logical allocation fails for the tree or subtree
    /// including this [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// The eventpair won't be signalled until allocation or logical allocation
    /// has completed; until then, the collection's current buffer count is
    /// ignored.
    ///
    /// If logical allocation fails for an attached subtree (using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]), the server end of the
    /// eventpair will close during that failure regardless of the number of
    /// buffers potenitally allocated in the overall buffer collection. This is
    /// for logical allocation consistency with normal allocation.
    ///
    /// 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 if any of the
    /// participants using the logical buffer collection (including the waiter
    /// itself) are less trusted, less reliable, or potentially blocked by the
    /// wait itself. Waiting asynchronously is recommended. Setting a deadline
    /// for the client wait may be prudent, depending on details of how the
    /// collection and/or its VMOs are used or shared. Failure to allocate a
    /// new/replacement buffer collection is better than getting stuck forever.
    ///
    /// The sysmem server itself intentionally does not perform any waiting on
    /// already-failed collections' VMOs to finish cleaning up before attempting
    /// a new allocation, and the sysmem server intentionally doesn't retry
    /// allocation if a new allocation fails due to out of memory, even if that
    /// failure is potentially due to continued existence of an old collection's
    /// VMOs. This `AttachLifetimeTracking` message is how an initiator can
    /// mitigate too much overlap of old VMO lifetimes with new VMO lifetimes,
    /// as long as the waiting client is careful to not create a deadlock.
    ///
    /// Continued existence of old collections that are still cleaning up is not
    /// the only reason that a new allocation may fail due to insufficient
    /// memory, even if the new allocation is allocating physically contiguous
    /// buffers. Overall system memory pressure can also be the cause of failure
    /// to allocate a new collection. See also
    /// [`fuchsia.memorypressure/Provider`].
    ///
    /// `AttachLifetimeTracking` is meant to be compatible with other protocols
    /// with a similar `AttachLifetimeTracking` message; duplicates of the same
    /// `eventpair` handle (server end) can be sent via more than one
    /// `AttachLifetimeTracking` message to different protocols, and the
    /// `ZX_EVENTPAIR_PEER_CLOSED` will be signalled for the client end when all
    /// the conditions are met (all holders of duplicates have closed their
    /// server end handle(s)). Also, thanks to how eventpair endponts work, the
    /// client end can (also) be duplicated without preventing the
    /// `ZX_EVENTPAIR_PEER_CLOSED` signal.
    ///
    /// The server intentionally doesn't "trust" any signals set on the
    /// `server_end`. This mechanism intentionally uses only
    /// `ZX_EVENTPAIR_PEER_CLOSED` set on the client end, which can't be set
    /// "early", and is only set when all handles to the server end eventpair
    /// are closed. No meaning is associated with any of the other signals, and
    /// clients should ignore any other signal bits on either end of the
    /// `eventpair`.
    ///
    /// 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 `BufferCollection` channel failure).
    ///
    /// All table fields are currently required.
    ///
    /// + request `server_end` This eventpair handle will be closed by the
    ///   sysmem server when buffers have been allocated initially and the
    ///   number of buffers is then less than or equal to `buffers_remaining`.
    /// + request `buffers_remaining` Wait for all but `buffers_remaining` (or
    ///   fewer) buffers to be fully deallocated. A number greater than zero 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 frame 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.
    pub fn r#attach_lifetime_tracking(
        &self,
        mut payload: BufferCollectionAttachLifetimeTrackingRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionProxyInterface::r#attach_lifetime_tracking(self, payload)
    }
}

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::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x11ac2555cf575b54,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionMarker>("sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        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<NodeGetNodeRefResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetNodeRefResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b3d0e51614df053,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionMarker>("get_node_ref")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetNodeRefResponse>(
            (),
            0x5b3d0e51614df053,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> 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::FlexibleResultType<NodeIsAlternateForResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a58e00157e0825,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionMarker>("is_alternate_for")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            &mut payload,
            0x3a58e00157e0825,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetBufferCollectionIdResponseFut = fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetBufferCollectionIdResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetBufferCollectionIdResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x77d19a494b78ba8c,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionMarker>("get_buffer_collection_id")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            NodeGetBufferCollectionIdResponse,
        >(
            (),
            0x77d19a494b78ba8c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

    type WaitForAllBuffersAllocatedResponseFut = fidl::client::QueryResponseFut<
        BufferCollectionWaitForAllBuffersAllocatedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#wait_for_all_buffers_allocated(&self) -> Self::WaitForAllBuffersAllocatedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BufferCollectionWaitForAllBuffersAllocatedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    BufferCollectionWaitForAllBuffersAllocatedResponse,
                    Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x62300344b61404e,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionMarker>("wait_for_all_buffers_allocated")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BufferCollectionWaitForAllBuffersAllocatedResult,
        >(
            (),
            0x62300344b61404e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(BufferCollectionEvent::_UnknownEvent { ordinal: 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.sysmem2/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 {
                0x11ac2555cf575b54 => {
                    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,
                        },
                    })
                }
                0x6a5cae7d6d6e04c6 => {
                    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::Release {
                        control_handle,
                    })
                }
                0xb41f1624f48c1e9 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5cde8914608d99b1 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x716b0af13d5c0806 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5209c77415b4dfad => {
                    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,
                    })
                }
                0x5b3d0e51614df053 => {
                    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,
                        },
                    })
                }
                0x3a58e00157e0825 => {
                    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 {payload: req,
                        responder: BufferCollectionIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x77d19a494b78ba8c => {
                    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::GetBufferCollectionId {
                        responder: BufferCollectionGetBufferCollectionIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x22dd3ea514eeffe1 => {
                    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::SetWeak {
                        control_handle,
                    })
                }
                0x38a44fc4d7724be9 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetWeakOkRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetWeakOkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::SetWeakOk {payload: req,
                        control_handle,
                    })
                }
                0x3f22f2a293d3cdac => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeAttachNodeTrackingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeAttachNodeTrackingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionRequest::AttachNodeTracking {payload: req,
                        control_handle,
                    })
                }
                0x1fde0f19d650197b => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x62300344b61404e => {
                    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::WaitForAllBuffersAllocated {
                        responder: BufferCollectionWaitForAllBuffersAllocatedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x35a5fe77ce939c10 => {
                    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::CheckAllBuffersAllocated {
                        responder: BufferCollectionCheckAllBuffersAllocatedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x46ac7d0008492982 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x3ecb510113116dcf => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(BufferCollectionRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(BufferCollectionRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BufferCollectionMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// [`fuchsia.sysmem2/BufferCollection`] is a connection directly from a
/// participant to sysmem re. a buffer collection; often the buffer collection
/// is shared with other participants which have their own `BufferCollection`
/// client end(s) associated with the same buffer collection.  In other words,
/// an instance of the `BufferCollection` interface is a view of a buffer
/// collection, not the buffer collection itself.
///
/// The `BufferCollection` connection exists to facilitate async indication of
/// when the buffer collection has been populated with buffers.
///
/// Also, the channel's closure by the sysmem server is an indication to the
/// client that the client should close all VMO handles that were obtained from
/// the `BufferCollection` ASAP.
///
/// Some buffer collections can use enough memory that it can be worth avoiding
/// allocation overlap (in time) using
/// [`fuchsia.sysmem2/BufferCollection.AttachLifetimeTracking`] so that the
/// initiator can tell when enough buffers of the buffer collection have been
/// fully deallocated prior to the initiator allocating a new buffer collection.
///
/// Epitaphs are not used in this protocol.
#[derive(Debug)]
pub enum BufferCollectionRequest {
    /// Ensure that previous messages have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    Sync { responder: BufferCollectionSyncResponder },
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    Release { control_handle: BufferCollectionControlHandle },
    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    SetName { payload: NodeSetNameRequest, control_handle: BufferCollectionControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    SetDebugClientInfo {
        payload: NodeSetDebugClientInfoRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    SetDebugTimeoutLogDeadline {
        payload: NodeSetDebugTimeoutLogDeadlineRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    SetVerboseLogging { control_handle: BufferCollectionControlHandle },
    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    GetNodeRef { responder: BufferCollectionGetNodeRefResponder },
    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    IsAlternateFor {
        payload: NodeIsAlternateForRequest,
        responder: BufferCollectionIsAlternateForResponder,
    },
    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    GetBufferCollectionId { responder: BufferCollectionGetBufferCollectionIdResponder },
    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    SetWeak { control_handle: BufferCollectionControlHandle },
    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    SetWeakOk { payload: NodeSetWeakOkRequest, control_handle: BufferCollectionControlHandle },
    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    AttachNodeTracking {
        payload: NodeAttachNodeTrackingRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// Provide [`fuchsia.sysmem2/BufferCollectionConstraints`] to the buffer
    /// collection.
    ///
    /// A participant may only call
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] up to once per
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// For buffer allocation to be attempted, all holders of a
    /// `BufferCollection` client end need to call `SetConstraints` before
    /// sysmem will attempt to allocate buffers.
    ///
    /// + request `constraints` These are the constraints on the buffer
    ///   collection imposed by the sending client/participant.  The
    ///   `constraints` field is not required to be set. If not set, the client
    ///   is not setting any actual constraints, but is indicating that the
    ///   client has no constraints to set. A client that doesn't set the
    ///   `constraints` field won't receive any VMO handles, but can still find
    ///   out how many buffers were allocated and can still refer to buffers by
    ///   their `buffer_index`.
    SetConstraints {
        payload: BufferCollectionSetConstraintsRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// Wait until all buffers are allocated.
    ///
    /// This FIDL call completes when buffers have been allocated, or completes
    /// with some failure detail if allocation has been attempted but failed.
    ///
    /// The following must occur before buffers will be allocated:
    ///   * All [`fuchsia.sysmem2/BufferCollectionToken`](s) of the buffer
    ///     collection must be turned in via `BindSharedCollection` to get a
    ///     [`fuchsia.sysmem2/BufferCollection`] (for brevity, this is assuming
    ///     [`fuchsia.sysmem2/BufferCollection.AttachToken`] isn't being used),
    ///     or have had [`fuchsia.sysmem2/BufferCollectionToken.Release`] sent
    ///     to them.
    ///   * All [`fuchsia.sysmem2/BufferCollection`](s) of the buffer collection
    ///     must have had [`fuchsia.sysmem2/BufferCollection.SetConstraints`]
    ///     sent to them, or had [`fuchsia.sysmem2/BufferCollection.Release`]
    ///     sent to them.
    ///
    /// - result `buffer_collection_info` The VMO handles and other related
    ///   info.
    /// * error `[fuchsia.sysmem2/Error.NO_MEMORY]` The request is valid but
    ///   cannot be fulfilled due to resource exhaustion.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION`] The request is
    ///   malformed.
    /// * error `[fuchsia.sysmem2/Error.CONSTRAINTS_INTERSECTION_EMPTY`] The
    ///   request is valid but cannot be satisfied, perhaps due to hardware
    ///   limitations. This can happen if participants have incompatible
    ///   constraints (empty intersection, roughly speaking). See the log for
    ///   more info. In cases where a participant could potentially be treated
    ///   as optional, see [`BufferCollectionTokenGroup`]. When using
    ///   [`fuchsia.sysmem2/BufferCollection.AttachToken`], this will be the
    ///   error code if there aren't enough buffers in the pre-existing
    ///   collection to satisfy the constraints set on the attached token and
    ///   any sub-tree of tokens derived from the attached token.
    WaitForAllBuffersAllocated { responder: BufferCollectionWaitForAllBuffersAllocatedResponder },
    /// Checks whether all the buffers have been allocated, in a polling
    /// fashion.
    ///
    /// * If the buffer collection has been allocated, returns success.
    /// * If the buffer collection failed allocation, returns the same
    ///   [`fuchsia.sysmem2/Error`] as
    ///   [`fuchsia.sysmem2/BufferCollection/WaitForAllBuffersAllocated`] would
    ///   return.
    /// * error [`fuchsia.sysmem2/Error.PENDING`] The buffer collection hasn't
    ///   attempted allocation yet. This means that WaitForAllBuffersAllocated
    ///   would not respond quickly.
    CheckAllBuffersAllocated { responder: BufferCollectionCheckAllBuffersAllocatedResponder },
    /// Create a new token to add a new participant to an existing logical
    /// buffer 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.
    ///
    /// When [`fuchsia.sysmem2/BufferCollection.AttachToken`] is used, the sub
    /// tree rooted at the attached [`fuchsia.sysmem2/BufferCollectionToken`]
    /// goes through the normal procedure of setting constraints or closing
    /// [`fuchsia.sysmem2/Node`](s), and then appearing to allocate buffers from
    /// clients' point of view, despite the possibility that all the buffers
    /// were actually allocated previously. This process is called "logical
    /// allocation". Most instances of "allocation" in docs for other messages
    /// can also be read as "allocation or logical allocation" while remaining
    /// valid, but we just say "allocation" in most places for brevity/clarity
    /// of explanation, with the details of "logical allocation" left for the
    /// docs here on `AttachToken`.
    ///
    /// Failure of an attached `Node` does not propagate to the parent of the
    /// attached `Node`. More generally, failure of a child `Node` is blocked
    /// from reaching its parent `Node` if the child is attached, or if the
    /// child is dispensable and the failure occurred after logical allocation
    /// (see [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`]).
    ///
    /// A participant may in some scenarios choose to initially use a
    /// dispensable token for a given instance of a delegate participant, and
    /// then later if the first instance of that delegate participant fails, a
    /// new second instance of that delegate participant my be given a token
    /// created with `AttachToken`.
    ///
    /// From the point of view of the [`fuchsia.sysmem2/BufferCollectionToken`]
    /// client end, the token acts like any other token. The client can
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] the token as needed,
    /// and can send the token to a different process/participant. The
    /// `BufferCollectionToken` `Node` should be converted to a
    /// `BufferCollection` `Node` as normal by sending
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or can be closed
    /// without causing subtree failure by sending
    /// [`fuchsia.sysmem2/BufferCollectionToken.Release`]. Assuming the former,
    /// the [`fuchsia.sysmem2/BufferCollection.SetConstraints`] message or
    /// [`fuchsia.sysmem2/BufferCollection.Release`] message should be sent to
    /// the `BufferCollection`.
    ///
    /// Within the subtree, a success result from
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`] means
    /// the subtree participants' constraints were satisfiable using the
    /// already-existing buffer collection, the already-established
    /// [`fuchsia.sysmem2/BufferCollectionInfo`] including image format
    /// constraints, and the already-existing other participants (already added
    /// via successful logical allocation) and their specified buffer counts in
    /// their constraints. A failure result means the new participants'
    /// constraints cannot be satisfied using the existing buffer collection and
    /// its already-added participants. Creating a new collection instead may
    /// allow all participants' 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.
    /// Further subtrees under this subtree are considered for logical
    /// allocation only after this subtree has completed logical allocation.
    ///
    /// Assignment of existing buffers to participants'
    /// [`fuchsia.sysmem2/BufferCollectionConstraints.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 [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`], which
    /// in contrast to `AttachToken`, has the created token `Node` + child
    /// `Node`(s) (in the created subtree but not in any subtree under this
    /// subtree) participate in constraints aggregation along with its parent
    /// during the parent's allocation or logical allocation.
    ///
    /// Similar to [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`], the
    /// newly created token needs to be [`fuchsia.sysmem2/Node.Sync`]ed to
    /// sysmem before the new token can be passed to `BindSharedCollection`. The
    /// `Sync` of the new token can be accomplished with
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after converting the created
    /// `BufferCollectionToken` to a `BufferCollection`. Alternately,
    /// [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on the new token also
    /// works. Or using [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`]
    /// works. As usual, 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.
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attentuation_mask` This allows attenuating the VMO
    ///   rights of the subtree. These values for `rights_attenuation_mask`
    ///   result in no attenuation (note that 0 is not on this list):
    ///   + ZX_RIGHT_SAME_RIGHTS (preferred)
    ///   + 0xFFFFFFFF (this is reasonable when an attenuation mask is computed)
    /// + request `token_request` The server end of the `BufferCollectionToken`
    ///   channel. The client retains the client end.
    AttachToken {
        payload: BufferCollectionAttachTokenRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// Set up an eventpair to be signalled (`ZX_EVENTPAIR_PEER_CLOSED`) when
    /// buffers have been allocated and only the specified number of buffers (or
    /// fewer) remain in the buffer collection.
    ///
    /// [`fuchsia.sysmem2/BufferCollection.AttachLifetimeTracking`] allows a
    /// client to wait until an old buffer collection is fully or mostly
    /// deallocated before attempting allocation of a new buffer collection. The
    /// eventpair is only signalled when the buffers of this collection have
    /// been fully deallocated (not just un-referenced by clients, but all the
    /// memory consumed by those buffers has been fully reclaimed/recycled), or
    /// when allocation or logical allocation fails for the tree or subtree
    /// including this [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// The eventpair won't be signalled until allocation or logical allocation
    /// has completed; until then, the collection's current buffer count is
    /// ignored.
    ///
    /// If logical allocation fails for an attached subtree (using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]), the server end of the
    /// eventpair will close during that failure regardless of the number of
    /// buffers potenitally allocated in the overall buffer collection. This is
    /// for logical allocation consistency with normal allocation.
    ///
    /// 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 if any of the
    /// participants using the logical buffer collection (including the waiter
    /// itself) are less trusted, less reliable, or potentially blocked by the
    /// wait itself. Waiting asynchronously is recommended. Setting a deadline
    /// for the client wait may be prudent, depending on details of how the
    /// collection and/or its VMOs are used or shared. Failure to allocate a
    /// new/replacement buffer collection is better than getting stuck forever.
    ///
    /// The sysmem server itself intentionally does not perform any waiting on
    /// already-failed collections' VMOs to finish cleaning up before attempting
    /// a new allocation, and the sysmem server intentionally doesn't retry
    /// allocation if a new allocation fails due to out of memory, even if that
    /// failure is potentially due to continued existence of an old collection's
    /// VMOs. This `AttachLifetimeTracking` message is how an initiator can
    /// mitigate too much overlap of old VMO lifetimes with new VMO lifetimes,
    /// as long as the waiting client is careful to not create a deadlock.
    ///
    /// Continued existence of old collections that are still cleaning up is not
    /// the only reason that a new allocation may fail due to insufficient
    /// memory, even if the new allocation is allocating physically contiguous
    /// buffers. Overall system memory pressure can also be the cause of failure
    /// to allocate a new collection. See also
    /// [`fuchsia.memorypressure/Provider`].
    ///
    /// `AttachLifetimeTracking` is meant to be compatible with other protocols
    /// with a similar `AttachLifetimeTracking` message; duplicates of the same
    /// `eventpair` handle (server end) can be sent via more than one
    /// `AttachLifetimeTracking` message to different protocols, and the
    /// `ZX_EVENTPAIR_PEER_CLOSED` will be signalled for the client end when all
    /// the conditions are met (all holders of duplicates have closed their
    /// server end handle(s)). Also, thanks to how eventpair endponts work, the
    /// client end can (also) be duplicated without preventing the
    /// `ZX_EVENTPAIR_PEER_CLOSED` signal.
    ///
    /// The server intentionally doesn't "trust" any signals set on the
    /// `server_end`. This mechanism intentionally uses only
    /// `ZX_EVENTPAIR_PEER_CLOSED` set on the client end, which can't be set
    /// "early", and is only set when all handles to the server end eventpair
    /// are closed. No meaning is associated with any of the other signals, and
    /// clients should ignore any other signal bits on either end of the
    /// `eventpair`.
    ///
    /// 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 `BufferCollection` channel failure).
    ///
    /// All table fields are currently required.
    ///
    /// + request `server_end` This eventpair handle will be closed by the
    ///   sysmem server when buffers have been allocated initially and the
    ///   number of buffers is then less than or equal to `buffers_remaining`.
    /// + request `buffers_remaining` Wait for all but `buffers_remaining` (or
    ///   fewer) buffers to be fully deallocated. A number greater than zero 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 frame 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.
    AttachLifetimeTracking {
        payload: BufferCollectionAttachLifetimeTrackingRequest,
        control_handle: BufferCollectionControlHandle,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: BufferCollectionControlHandle,
        method_type: fidl::MethodType,
    },
}

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_release(self) -> Option<(BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::Release { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(NodeSetDebugTimeoutLogDeadlineRequest, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetDebugTimeoutLogDeadline { payload, control_handle } =
            self
        {
            Some((payload, 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<(NodeIsAlternateForRequest, BufferCollectionIsAlternateForResponder)> {
        if let BufferCollectionRequest::IsAlternateFor { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_weak_ok(self) -> Option<(NodeSetWeakOkRequest, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::SetWeakOk { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_node_tracking(
        self,
    ) -> Option<(NodeAttachNodeTrackingRequest, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::AttachNodeTracking { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_token(
        self,
    ) -> Option<(BufferCollectionAttachTokenRequest, BufferCollectionControlHandle)> {
        if let BufferCollectionRequest::AttachToken { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BufferCollectionRequest::Sync { .. } => "sync",
            BufferCollectionRequest::Release { .. } => "release",
            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::GetBufferCollectionId { .. } => "get_buffer_collection_id",
            BufferCollectionRequest::SetWeak { .. } => "set_weak",
            BufferCollectionRequest::SetWeakOk { .. } => "set_weak_ok",
            BufferCollectionRequest::AttachNodeTracking { .. } => "attach_node_tracking",
            BufferCollectionRequest::SetConstraints { .. } => "set_constraints",
            BufferCollectionRequest::WaitForAllBuffersAllocated { .. } => {
                "wait_for_all_buffers_allocated"
            }
            BufferCollectionRequest::CheckAllBuffersAllocated { .. } => {
                "check_all_buffers_allocated"
            }
            BufferCollectionRequest::AttachToken { .. } => "attach_token",
            BufferCollectionRequest::AttachLifetimeTracking { .. } => "attach_lifetime_tracking",
            BufferCollectionRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            BufferCollectionRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

#[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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 payload: NodeGetNodeRefResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: NodeGetNodeRefResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BufferCollectionGetBufferCollectionIdResponder {
    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 BufferCollectionGetBufferCollectionIdResponder {
    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 BufferCollectionGetBufferCollectionIdResponder {
    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 BufferCollectionGetBufferCollectionIdResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: &NodeGetBufferCollectionIdResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: &NodeGetBufferCollectionIdResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BufferCollectionWaitForAllBuffersAllocatedResponder {
    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 BufferCollectionWaitForAllBuffersAllocatedResponder {
    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 BufferCollectionWaitForAllBuffersAllocatedResponder {
    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 BufferCollectionWaitForAllBuffersAllocatedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<BufferCollectionWaitForAllBuffersAllocatedResponse, Error>,
    ) -> 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<BufferCollectionWaitForAllBuffersAllocatedResponse, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BufferCollectionCheckAllBuffersAllocatedResponder {
    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 BufferCollectionCheckAllBuffersAllocatedResponder {
    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 BufferCollectionCheckAllBuffersAllocatedResponder {
    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 BufferCollectionCheckAllBuffersAllocatedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> 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<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

#[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#release(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, payload: &NodeSetNameRequest) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(
        &self,
        payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(
        &self,
        payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<NodeGetNodeRefResponse, 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,
        payload: NodeIsAlternateForRequest,
    ) -> Self::IsAlternateForResponseFut;
    type GetBufferCollectionIdResponseFut: std::future::Future<Output = Result<NodeGetBufferCollectionIdResponse, fidl::Error>>
        + Send;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut;
    fn r#set_weak(&self) -> Result<(), fidl::Error>;
    fn r#set_weak_ok(&self, payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error>;
    fn r#attach_node_tracking(
        &self,
        payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error>;
    type DuplicateSyncResponseFut: std::future::Future<
            Output = Result<BufferCollectionTokenDuplicateSyncResponse, fidl::Error>,
        > + Send;
    fn r#duplicate_sync(
        &self,
        payload: &BufferCollectionTokenDuplicateSyncRequest,
    ) -> Self::DuplicateSyncResponseFut;
    fn r#duplicate(
        &self,
        payload: BufferCollectionTokenDuplicateRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_dispensable(&self) -> Result<(), fidl::Error>;
    fn r#create_buffer_collection_token_group(
        &self,
        payload: BufferCollectionTokenCreateBufferCollectionTokenGroupRequest,
    ) -> 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.sysmem2/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 have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionTokenProxyInterface::r#sync(self)
    }

    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    pub fn r#release(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#release(self)
    }

    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    pub fn r#set_name(&self, mut payload: &NodeSetNameRequest) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_name(self, payload)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    pub fn r#set_debug_client_info(
        &self,
        mut payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_debug_client_info(self, payload)
    }

    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    pub fn r#set_debug_timeout_log_deadline(
        &self,
        mut payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_debug_timeout_log_deadline(self, payload)
    }

    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#get_node_ref(self)
    }

    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    pub fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#is_alternate_for(self, payload)
    }

    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    pub fn r#get_buffer_collection_id(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#get_buffer_collection_id(self)
    }

    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    pub fn r#set_weak(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_weak(self)
    }

    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    pub fn r#set_weak_ok(&self, mut payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#set_weak_ok(self, payload)
    }

    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    pub fn r#attach_node_tracking(
        &self,
        mut payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#attach_node_tracking(self, payload)
    }

    /// Create additional [`fuchsia.sysmem2/BufferCollectionToken`](s) from this
    /// one, referring to the same buffer collection.
    ///
    /// The created tokens are children of this token in the
    /// [`fuchsia.sysmem2/Node`] heirarchy.
    ///
    /// This method can be used to add more participants, by transferring the
    /// newly created tokens to additional participants.
    ///
    /// A new token will be returned for each entry in the
    /// `rights_attenuation_masks` array.
    ///
    /// If the called token may not actually be a valid token due to a
    /// potentially hostile/untrusted provider of the token, consider using
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] first
    /// instead of potentially getting stuck indefinitely if
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] never responds
    /// due to the calling token not being a real token.
    ///
    /// In contrast to [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`], no
    /// separate [`fuchsia.sysmem2/Node.Sync`] is needed after calling this
    /// method, because the sync step is included in this call, at the cost of a
    /// round trip during this call.
    ///
    /// All tokens must be turned in to sysmem via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] or
    /// [`fuchsia.sysmem2/Node.Release`] for a `BufferCollection` to
    /// successfully allocate buffers (or to logically allocate buffers in the
    /// case of subtrees involving
    /// [`fuchsia.sysmem2/BufferCollectionToken.AttachToken`]).
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attenuation_mask` 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.
    /// - response `tokens` The client ends of each newly created token.
    pub fn r#duplicate_sync(
        &self,
        mut payload: &BufferCollectionTokenDuplicateSyncRequest,
    ) -> fidl::client::QueryResponseFut<
        BufferCollectionTokenDuplicateSyncResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenProxyInterface::r#duplicate_sync(self, payload)
    }

    /// Create an additional [`fuchsia.sysmem2/BufferCollectionToken`] from this
    /// one, referring to the same buffer collection.
    ///
    /// The created token is a child of this token in the
    /// [`fuchsia.sysmem2/Node`] heirarchy.
    ///
    /// This method can be used to add a participant, by transferring the newly
    /// created token to another participant.
    ///
    /// This one-way message can be used instead of the two-way
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] FIDL call in
    /// performance sensitive cases where it would be undesireable to wait for
    /// sysmem to respond to
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] or when the
    /// client code isn't structured to make it easy to duplicate all the needed
    /// tokens at once.
    ///
    /// After sending one or more `Duplicate` messages, and before sending the
    /// newly created child tokens to other participants (or to other
    /// [`fuchsia.sysmem2/Allocator`] channels), the client must send a
    /// [`fuchsia.sysmem2/Node.Sync`] and wait for the `Sync` 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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] or
    /// [`fuchsia.sysmem2/Node.Release`] for a `BufferCollection` to
    /// successfully allocate buffers.
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attenuation_mask` The 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
    ///   delegate 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)
    /// + request `token_request` is the server end of a `BufferCollectionToken`
    ///   channel. The client end of this channel acts as another participant in
    ///   the shared buffer collection.
    pub fn r#duplicate(
        &self,
        mut payload: BufferCollectionTokenDuplicateRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#duplicate(self, payload)
    }

    /// Set this [`fuchsia.sysmem2/BufferCollectionToken`] to dispensable.
    ///
    /// When the `BufferCollectionToken` is converted to a
    /// [`fuchsia.sysmem2/BufferCollection`], the dispensable status applies to
    /// the `BufferCollection` also.
    ///
    /// Normally, if a client closes a [`fuchsia.sysmem2/BufferCollection`]
    /// client end without having sent
    /// [`fuchsia.sysmem2/BufferCollection.Release`] first, the
    /// `BufferCollection` [`fuchisa.sysmem2/Node`] will fail, which also
    /// propagates failure to the parent [`fuchsia.sysmem2/Node`] and so on up
    /// to the root `Node`, which fails the whole buffer collection. In
    /// contrast, a dispensable `Node` can fail after buffers are allocated
    /// without causing failure of its parent in the [`fuchsia.sysmem2/Node`]
    /// heirarchy.
    ///
    /// The dispensable `Node` participates in constraints aggregation along
    /// with its parent before buffer allocation. If the dispensable `Node`
    /// fails before buffers are allocated, the failure propagates to the
    /// dispensable `Node`'s parent.
    ///
    /// After buffers are allocated, failure of the dispensable `Node` (or any
    /// child of the dispensable `Node`) does not propagate to the dispensable
    /// `Node`'s parent. Failure does propagate from a normal child of a
    /// dispensable `Node` to the dispensable `Node`.  Failure of a child is
    /// blocked from reaching its parent if the child is attached using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`], or if the child is
    /// dispensable and the failure occurred after allocation.
    ///
    /// A dispensable `Node` 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
    /// `Node`'s point of view.
    ///
    /// In contrast, `BufferCollection.AttachToken` can be used to create a
    /// `BufferCollectionToken` which does not participate in constraints
    /// aggregation with its parent `Node`, and whose failure at any time does
    /// not propagate to its parent `Node`, and whose potential delay providing
    /// constraints does not prevent the parent `Node` from completing its
    /// buffer allocation.
    ///
    /// An initiator (creator of the root `Node` using
    /// [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`]) may in some
    /// scenarios choose to initially use a dispensable `Node` for a first
    /// 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 `BufferCollectionToken` created with `AttachToken`.
    ///
    /// Normally a client will `SetDispensable` on a `BufferCollectionToken`
    /// shortly before sending the dispensable `BufferCollectionToken` to a
    /// delegate participant. Because `SetDispensable` prevents propagation of
    /// child `Node` failure to parent `Node`(s), if the client was relying on
    /// noticing child failure via failure of the parent `Node` retained by the
    /// client, the client may instead need to notice failure via other means.
    /// If other means aren't available/convenient, the client can instead
    /// retain the dispensable `Node` and create a child `Node` under that to
    /// send to the delegate participant, retaining this `Node` in order to
    /// notice failure of the subtree rooted at this `Node` via this `Node`'s
    /// ZX_CHANNEL_PEER_CLOSED signal, and take whatever action is appropriate
    /// (e.g. starting a new instance of the delegate participant and handing it
    /// a `BufferCollectionToken` created using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`], or propagate failure
    /// and clean up in a client-specific way).
    ///
    /// While it is possible (and potentially useful) to `SetDispensable` on a
    /// direct child of a `BufferCollectionTokenGroup` `Node`, it isn't possible
    /// to later replace a failed dispensable `Node` that was a direct child of
    /// a `BufferCollectionTokenGroup` 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 that's a direct child of the group and make the
    /// existing dispensable token a child of the additional token.  This way,
    /// the additional token 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)
    }

    /// Create a logical OR among a set of tokens, called a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    ///
    /// Most sysmem clients and many participants don't need to care about this
    /// message or about `BufferCollectionTokenGroup`(s). However, in some cases
    /// a participant wants to attempt to include one set of delegate
    /// participants, but if constraints don't combine successfully that way,
    /// fall back to a different (possibly overlapping) set of delegate
    /// participants, and/or fall back to a less demanding strategy (in terms of
    /// how strict the [`fuchisa.sysmem2/BufferCollectionConstraints`] are,
    /// across all involved delegate participants). In such cases, a
    /// `BufferCollectionTokenGroup` is useful.
    ///
    /// A `BufferCollectionTokenGroup` is used to create a 1 of N OR among N
    /// child [`fuchsia.sysmem2/BufferCollectionToken`](s).  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 (this is
    /// simimlar to a normal `BufferCollection` server end closing on failure to
    /// allocate a logical buffer collection or later async failure of a 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
    /// `BufferCollectionToken` for this purpose as a direct parent of the
    /// `BufferCollectionTokenGroup`.
    ///
    /// All table fields are currently required.
    ///
    /// + request `group_request` The server end of a
    ///   `BufferCollectionTokenGroup` channel to be served by sysmem.
    pub fn r#create_buffer_collection_token_group(
        &self,
        mut payload: BufferCollectionTokenCreateBufferCollectionTokenGroupRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenProxyInterface::r#create_buffer_collection_token_group(self, payload)
    }
}

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::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x11ac2555cf575b54,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenMarker>("sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        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<NodeGetNodeRefResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetNodeRefResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b3d0e51614df053,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenMarker>("get_node_ref")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetNodeRefResponse>(
            (),
            0x5b3d0e51614df053,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> 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::FlexibleResultType<NodeIsAlternateForResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a58e00157e0825,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenMarker>("is_alternate_for")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            &mut payload,
            0x3a58e00157e0825,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetBufferCollectionIdResponseFut = fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetBufferCollectionIdResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetBufferCollectionIdResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x77d19a494b78ba8c,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenMarker>("get_buffer_collection_id")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            NodeGetBufferCollectionIdResponse,
        >(
            (),
            0x77d19a494b78ba8c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

    type DuplicateSyncResponseFut = fidl::client::QueryResponseFut<
        BufferCollectionTokenDuplicateSyncResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#duplicate_sync(
        &self,
        mut payload: &BufferCollectionTokenDuplicateSyncRequest,
    ) -> Self::DuplicateSyncResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BufferCollectionTokenDuplicateSyncResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<BufferCollectionTokenDuplicateSyncResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1c1af9919d1ca45c,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenMarker>("duplicate_sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            BufferCollectionTokenDuplicateSyncRequest,
            BufferCollectionTokenDuplicateSyncResponse,
        >(
            payload,
            0x1c1af9919d1ca45c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(BufferCollectionTokenEvent::_UnknownEvent {
                    ordinal: 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.sysmem2/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 {
                0x11ac2555cf575b54 => {
                    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,
                        },
                    })
                }
                0x6a5cae7d6d6e04c6 => {
                    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::Release {
                        control_handle,
                    })
                }
                0xb41f1624f48c1e9 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5cde8914608d99b1 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x716b0af13d5c0806 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5209c77415b4dfad => {
                    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,
                    })
                }
                0x5b3d0e51614df053 => {
                    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,
                        },
                    })
                }
                0x3a58e00157e0825 => {
                    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 {payload: req,
                        responder: BufferCollectionTokenIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x77d19a494b78ba8c => {
                    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::GetBufferCollectionId {
                        responder: BufferCollectionTokenGetBufferCollectionIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x22dd3ea514eeffe1 => {
                    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::SetWeak {
                        control_handle,
                    })
                }
                0x38a44fc4d7724be9 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetWeakOkRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetWeakOkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::SetWeakOk {payload: req,
                        control_handle,
                    })
                }
                0x3f22f2a293d3cdac => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeAttachNodeTrackingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeAttachNodeTrackingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenRequest::AttachNodeTracking {payload: req,
                        control_handle,
                    })
                }
                0x1c1af9919d1ca45c => {
                    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 {payload: req,
                        responder: BufferCollectionTokenDuplicateSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x73e78f92ee7fb887 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x228acf979254df8b => {
                    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,
                    })
                }
                0x30f8d48e77bd36f2 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(BufferCollectionTokenRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionTokenControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(BufferCollectionTokenRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionTokenControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BufferCollectionTokenMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// A [`fuchsia.sysmem2/BufferCollectionToken`] is not a buffer collection, but
/// rather is a way to identify a specific potential shared buffer collection,
/// and a way to distribute that potential shared buffer collection to
/// additional participants prior to the buffer collection allocating any
/// buffers.
///
/// Epitaphs are not used in this protocol.
///
/// We use a channel for the `BufferCollectionToken` instead of a single
/// `eventpair` (pair) because this way we can detect error conditions like a
/// participant failing mid-create.
#[derive(Debug)]
pub enum BufferCollectionTokenRequest {
    /// Ensure that previous messages have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    Sync { responder: BufferCollectionTokenSyncResponder },
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    Release { control_handle: BufferCollectionTokenControlHandle },
    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    SetName { payload: NodeSetNameRequest, control_handle: BufferCollectionTokenControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    SetDebugClientInfo {
        payload: NodeSetDebugClientInfoRequest,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    SetDebugTimeoutLogDeadline {
        payload: NodeSetDebugTimeoutLogDeadlineRequest,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    SetVerboseLogging { control_handle: BufferCollectionTokenControlHandle },
    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    GetNodeRef { responder: BufferCollectionTokenGetNodeRefResponder },
    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    IsAlternateFor {
        payload: NodeIsAlternateForRequest,
        responder: BufferCollectionTokenIsAlternateForResponder,
    },
    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    GetBufferCollectionId { responder: BufferCollectionTokenGetBufferCollectionIdResponder },
    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    SetWeak { control_handle: BufferCollectionTokenControlHandle },
    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    SetWeakOk { payload: NodeSetWeakOkRequest, control_handle: BufferCollectionTokenControlHandle },
    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    AttachNodeTracking {
        payload: NodeAttachNodeTrackingRequest,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// Create additional [`fuchsia.sysmem2/BufferCollectionToken`](s) from this
    /// one, referring to the same buffer collection.
    ///
    /// The created tokens are children of this token in the
    /// [`fuchsia.sysmem2/Node`] heirarchy.
    ///
    /// This method can be used to add more participants, by transferring the
    /// newly created tokens to additional participants.
    ///
    /// A new token will be returned for each entry in the
    /// `rights_attenuation_masks` array.
    ///
    /// If the called token may not actually be a valid token due to a
    /// potentially hostile/untrusted provider of the token, consider using
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] first
    /// instead of potentially getting stuck indefinitely if
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] never responds
    /// due to the calling token not being a real token.
    ///
    /// In contrast to [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`], no
    /// separate [`fuchsia.sysmem2/Node.Sync`] is needed after calling this
    /// method, because the sync step is included in this call, at the cost of a
    /// round trip during this call.
    ///
    /// All tokens must be turned in to sysmem via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] or
    /// [`fuchsia.sysmem2/Node.Release`] for a `BufferCollection` to
    /// successfully allocate buffers (or to logically allocate buffers in the
    /// case of subtrees involving
    /// [`fuchsia.sysmem2/BufferCollectionToken.AttachToken`]).
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attenuation_mask` 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.
    /// - response `tokens` The client ends of each newly created token.
    DuplicateSync {
        payload: BufferCollectionTokenDuplicateSyncRequest,
        responder: BufferCollectionTokenDuplicateSyncResponder,
    },
    /// Create an additional [`fuchsia.sysmem2/BufferCollectionToken`] from this
    /// one, referring to the same buffer collection.
    ///
    /// The created token is a child of this token in the
    /// [`fuchsia.sysmem2/Node`] heirarchy.
    ///
    /// This method can be used to add a participant, by transferring the newly
    /// created token to another participant.
    ///
    /// This one-way message can be used instead of the two-way
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] FIDL call in
    /// performance sensitive cases where it would be undesireable to wait for
    /// sysmem to respond to
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] or when the
    /// client code isn't structured to make it easy to duplicate all the needed
    /// tokens at once.
    ///
    /// After sending one or more `Duplicate` messages, and before sending the
    /// newly created child tokens to other participants (or to other
    /// [`fuchsia.sysmem2/Allocator`] channels), the client must send a
    /// [`fuchsia.sysmem2/Node.Sync`] and wait for the `Sync` 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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] or
    /// [`fuchsia.sysmem2/Node.Release`] for a `BufferCollection` to
    /// successfully allocate buffers.
    ///
    /// All table fields are currently required.
    ///
    /// + request `rights_attenuation_mask` The 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
    ///   delegate 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)
    /// + request `token_request` is the server end of a `BufferCollectionToken`
    ///   channel. The client end of this channel acts as another participant in
    ///   the shared buffer collection.
    Duplicate {
        payload: BufferCollectionTokenDuplicateRequest,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// Set this [`fuchsia.sysmem2/BufferCollectionToken`] to dispensable.
    ///
    /// When the `BufferCollectionToken` is converted to a
    /// [`fuchsia.sysmem2/BufferCollection`], the dispensable status applies to
    /// the `BufferCollection` also.
    ///
    /// Normally, if a client closes a [`fuchsia.sysmem2/BufferCollection`]
    /// client end without having sent
    /// [`fuchsia.sysmem2/BufferCollection.Release`] first, the
    /// `BufferCollection` [`fuchisa.sysmem2/Node`] will fail, which also
    /// propagates failure to the parent [`fuchsia.sysmem2/Node`] and so on up
    /// to the root `Node`, which fails the whole buffer collection. In
    /// contrast, a dispensable `Node` can fail after buffers are allocated
    /// without causing failure of its parent in the [`fuchsia.sysmem2/Node`]
    /// heirarchy.
    ///
    /// The dispensable `Node` participates in constraints aggregation along
    /// with its parent before buffer allocation. If the dispensable `Node`
    /// fails before buffers are allocated, the failure propagates to the
    /// dispensable `Node`'s parent.
    ///
    /// After buffers are allocated, failure of the dispensable `Node` (or any
    /// child of the dispensable `Node`) does not propagate to the dispensable
    /// `Node`'s parent. Failure does propagate from a normal child of a
    /// dispensable `Node` to the dispensable `Node`.  Failure of a child is
    /// blocked from reaching its parent if the child is attached using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`], or if the child is
    /// dispensable and the failure occurred after allocation.
    ///
    /// A dispensable `Node` 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
    /// `Node`'s point of view.
    ///
    /// In contrast, `BufferCollection.AttachToken` can be used to create a
    /// `BufferCollectionToken` which does not participate in constraints
    /// aggregation with its parent `Node`, and whose failure at any time does
    /// not propagate to its parent `Node`, and whose potential delay providing
    /// constraints does not prevent the parent `Node` from completing its
    /// buffer allocation.
    ///
    /// An initiator (creator of the root `Node` using
    /// [`fuchsia.sysmem2/Allocator.AllocateSharedCollection`]) may in some
    /// scenarios choose to initially use a dispensable `Node` for a first
    /// 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 `BufferCollectionToken` created with `AttachToken`.
    ///
    /// Normally a client will `SetDispensable` on a `BufferCollectionToken`
    /// shortly before sending the dispensable `BufferCollectionToken` to a
    /// delegate participant. Because `SetDispensable` prevents propagation of
    /// child `Node` failure to parent `Node`(s), if the client was relying on
    /// noticing child failure via failure of the parent `Node` retained by the
    /// client, the client may instead need to notice failure via other means.
    /// If other means aren't available/convenient, the client can instead
    /// retain the dispensable `Node` and create a child `Node` under that to
    /// send to the delegate participant, retaining this `Node` in order to
    /// notice failure of the subtree rooted at this `Node` via this `Node`'s
    /// ZX_CHANNEL_PEER_CLOSED signal, and take whatever action is appropriate
    /// (e.g. starting a new instance of the delegate participant and handing it
    /// a `BufferCollectionToken` created using
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`], or propagate failure
    /// and clean up in a client-specific way).
    ///
    /// While it is possible (and potentially useful) to `SetDispensable` on a
    /// direct child of a `BufferCollectionTokenGroup` `Node`, it isn't possible
    /// to later replace a failed dispensable `Node` that was a direct child of
    /// a `BufferCollectionTokenGroup` 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 that's a direct child of the group and make the
    /// existing dispensable token a child of the additional token.  This way,
    /// the additional token 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 },
    /// Create a logical OR among a set of tokens, called a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    ///
    /// Most sysmem clients and many participants don't need to care about this
    /// message or about `BufferCollectionTokenGroup`(s). However, in some cases
    /// a participant wants to attempt to include one set of delegate
    /// participants, but if constraints don't combine successfully that way,
    /// fall back to a different (possibly overlapping) set of delegate
    /// participants, and/or fall back to a less demanding strategy (in terms of
    /// how strict the [`fuchisa.sysmem2/BufferCollectionConstraints`] are,
    /// across all involved delegate participants). In such cases, a
    /// `BufferCollectionTokenGroup` is useful.
    ///
    /// A `BufferCollectionTokenGroup` is used to create a 1 of N OR among N
    /// child [`fuchsia.sysmem2/BufferCollectionToken`](s).  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 (this is
    /// simimlar to a normal `BufferCollection` server end closing on failure to
    /// allocate a logical buffer collection or later async failure of a 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
    /// `BufferCollectionToken` for this purpose as a direct parent of the
    /// `BufferCollectionTokenGroup`.
    ///
    /// All table fields are currently required.
    ///
    /// + request `group_request` The server end of a
    ///   `BufferCollectionTokenGroup` channel to be served by sysmem.
    CreateBufferCollectionTokenGroup {
        payload: BufferCollectionTokenCreateBufferCollectionTokenGroupRequest,
        control_handle: BufferCollectionTokenControlHandle,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: BufferCollectionTokenControlHandle,
        method_type: fidl::MethodType,
    },
}

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_release(self) -> Option<(BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::Release { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(NodeSetDebugTimeoutLogDeadlineRequest, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetDebugTimeoutLogDeadline {
            payload,
            control_handle,
        } = self
        {
            Some((payload, 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<(NodeIsAlternateForRequest, BufferCollectionTokenIsAlternateForResponder)> {
        if let BufferCollectionTokenRequest::IsAlternateFor { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_buffer_collection_id(
        self,
    ) -> Option<(BufferCollectionTokenGetBufferCollectionIdResponder)> {
        if let BufferCollectionTokenRequest::GetBufferCollectionId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_weak_ok(
        self,
    ) -> Option<(NodeSetWeakOkRequest, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::SetWeakOk { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_node_tracking(
        self,
    ) -> Option<(NodeAttachNodeTrackingRequest, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::AttachNodeTracking { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_duplicate(
        self,
    ) -> Option<(BufferCollectionTokenDuplicateRequest, BufferCollectionTokenControlHandle)> {
        if let BufferCollectionTokenRequest::Duplicate { payload, control_handle } = self {
            Some((payload, 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<(
        BufferCollectionTokenCreateBufferCollectionTokenGroupRequest,
        BufferCollectionTokenControlHandle,
    )> {
        if let BufferCollectionTokenRequest::CreateBufferCollectionTokenGroup {
            payload,
            control_handle,
        } = self
        {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BufferCollectionTokenRequest::Sync { .. } => "sync",
            BufferCollectionTokenRequest::Release { .. } => "release",
            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::GetBufferCollectionId { .. } => {
                "get_buffer_collection_id"
            }
            BufferCollectionTokenRequest::SetWeak { .. } => "set_weak",
            BufferCollectionTokenRequest::SetWeakOk { .. } => "set_weak_ok",
            BufferCollectionTokenRequest::AttachNodeTracking { .. } => "attach_node_tracking",
            BufferCollectionTokenRequest::DuplicateSync { .. } => "duplicate_sync",
            BufferCollectionTokenRequest::Duplicate { .. } => "duplicate",
            BufferCollectionTokenRequest::SetDispensable { .. } => "set_dispensable",
            BufferCollectionTokenRequest::CreateBufferCollectionTokenGroup { .. } => {
                "create_buffer_collection_token_group"
            }
            BufferCollectionTokenRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            BufferCollectionTokenRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

#[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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 payload: NodeGetNodeRefResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: NodeGetNodeRefResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BufferCollectionTokenGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGetBufferCollectionIdResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: &NodeGetBufferCollectionIdResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: &NodeGetBufferCollectionIdResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[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 payload: BufferCollectionTokenDuplicateSyncResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: BufferCollectionTokenDuplicateSyncResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[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#release(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, payload: &NodeSetNameRequest) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(
        &self,
        payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(
        &self,
        payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<NodeGetNodeRefResponse, 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,
        payload: NodeIsAlternateForRequest,
    ) -> Self::IsAlternateForResponseFut;
    type GetBufferCollectionIdResponseFut: std::future::Future<Output = Result<NodeGetBufferCollectionIdResponse, fidl::Error>>
        + Send;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut;
    fn r#set_weak(&self) -> Result<(), fidl::Error>;
    fn r#set_weak_ok(&self, payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error>;
    fn r#attach_node_tracking(
        &self,
        payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error>;
    fn r#create_child(
        &self,
        payload: BufferCollectionTokenGroupCreateChildRequest,
    ) -> Result<(), fidl::Error>;
    type CreateChildrenSyncResponseFut: std::future::Future<
            Output = Result<BufferCollectionTokenGroupCreateChildrenSyncResponse, fidl::Error>,
        > + Send;
    fn r#create_children_sync(
        &self,
        payload: &BufferCollectionTokenGroupCreateChildrenSyncRequest,
    ) -> 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.sysmem2/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 have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BufferCollectionTokenGroupProxyInterface::r#sync(self)
    }

    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    pub fn r#release(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#release(self)
    }

    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    pub fn r#set_name(&self, mut payload: &NodeSetNameRequest) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_name(self, payload)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    pub fn r#set_debug_client_info(
        &self,
        mut payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_debug_client_info(self, payload)
    }

    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    pub fn r#set_debug_timeout_log_deadline(
        &self,
        mut payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_debug_timeout_log_deadline(self, payload)
    }

    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#get_node_ref(self)
    }

    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    pub fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#is_alternate_for(self, payload)
    }

    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    pub fn r#get_buffer_collection_id(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#get_buffer_collection_id(self)
    }

    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    pub fn r#set_weak(&self) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_weak(self)
    }

    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    pub fn r#set_weak_ok(&self, mut payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#set_weak_ok(self, payload)
    }

    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    pub fn r#attach_node_tracking(
        &self,
        mut payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error> {
        BufferCollectionTokenGroupProxyInterface::r#attach_node_tracking(self, payload)
    }

    /// Create a child [`fuchsia.sysmem2/BufferCollectionToken`]. Only one child
    /// (including its children) will be selected during allocation (or logical
    /// allocation).
    ///
    /// Before passing the client end of this token to
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], completion of
    /// [`fuchsia.sysmem2/Node.Sync`] after
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`] is required.
    /// Or the client can use
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChildrenSync`] which
    /// essentially includes the `Sync`.
    ///
    /// Sending CreateChild after AllChildrenPresent is not permitted; this will
    /// fail the group's subtree and close the connection.
    ///
    /// After all children have been created, send AllChildrenPresent.
    ///
    /// + request `token_request` The server end of the new token channel.
    /// + request `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. When the value isn't
    ///   ZX_RIGHT_SAME_RIGHTS, the value is interpretted as a bitmask with 0
    ///   bits ensuring those rights are attentuated, so 0xFFFFFFFF is a synonym
    ///   for ZX_RIGHT_SAME_RIGHTS. The value 0 is not allowed and intentionally
    ///   causes subtree failure.
    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
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`], no
    /// [`fuchsia.sysmem2/Node.Sync`] is required before passing the client end
    /// of a returned token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`].
    ///
    /// 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
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`] and
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.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.
    ///
    /// Sending CreateChildrenSync after AllChildrenPresent is not permitted;
    /// this will fail the group's subtree and close the connection.
    ///
    /// After all children have been created, send AllChildrenPresent.
    ///
    /// + request `rights_attentuation_masks` The size of the
    ///   `rights_attentuation_masks` determines the number of created child
    ///   tokens. The value ZX_RIGHT_SAME_RIGHTS doesn't attenuate any rights.
    ///   The value 0xFFFFFFFF is a synonym for ZX_RIGHT_SAME_RIGHTS. For any
    ///   other value, each 0 bit in the mask attenuates that right.
    /// - response `tokens` The created child tokens.
    pub fn r#create_children_sync(
        &self,
        mut payload: &BufferCollectionTokenGroupCreateChildrenSyncRequest,
    ) -> fidl::client::QueryResponseFut<
        BufferCollectionTokenGroupCreateChildrenSyncResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BufferCollectionTokenGroupProxyInterface::r#create_children_sync(self, payload)
    }

    /// Indicate that no more children will be created.
    ///
    /// After creating all children, the client should send
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent`] to
    /// inform sysmem that no more children will be created, so that sysmem can
    /// know when it's ok to start aggregating constraints.
    ///
    /// Sending CreateChild after AllChildrenPresent is not permitted; this will
    /// fail the group's subtree and close the connection.
    ///
    /// If [`fuchsia.sysmem2/Node.Release`] is to be sent, it should be sent
    /// after `AllChildrenPresent`, else failure of the group's subtree will be
    /// triggered. This is intentionally not analogous to how `Release` without
    /// prior [`fuchsia.sysmem2/BufferCollection.SetConstraints`] doesn't cause
    /// subtree failure.
    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::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x11ac2555cf575b54,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenGroupMarker>("sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        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<NodeGetNodeRefResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetNodeRefResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b3d0e51614df053,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenGroupMarker>("get_node_ref")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetNodeRefResponse>(
            (),
            0x5b3d0e51614df053,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> 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::FlexibleResultType<NodeIsAlternateForResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a58e00157e0825,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenGroupMarker>("is_alternate_for")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            &mut payload,
            0x3a58e00157e0825,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetBufferCollectionIdResponseFut = fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetBufferCollectionIdResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetBufferCollectionIdResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x77d19a494b78ba8c,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenGroupMarker>("get_buffer_collection_id")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            NodeGetBufferCollectionIdResponse,
        >(
            (),
            0x77d19a494b78ba8c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

    type CreateChildrenSyncResponseFut = fidl::client::QueryResponseFut<
        BufferCollectionTokenGroupCreateChildrenSyncResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_children_sync(
        &self,
        mut payload: &BufferCollectionTokenGroupCreateChildrenSyncRequest,
    ) -> Self::CreateChildrenSyncResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BufferCollectionTokenGroupCreateChildrenSyncResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<BufferCollectionTokenGroupCreateChildrenSyncResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x15dea448c536070a,
            >(_buf?)?
            .into_result_fdomain::<BufferCollectionTokenGroupMarker>("create_children_sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            BufferCollectionTokenGroupCreateChildrenSyncRequest,
            BufferCollectionTokenGroupCreateChildrenSyncResponse,
        >(
            payload,
            0x15dea448c536070a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(BufferCollectionTokenGroupEvent::_UnknownEvent {
                    ordinal: 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.sysmem2/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 {
                0x11ac2555cf575b54 => {
                    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,
                        },
                    })
                }
                0x6a5cae7d6d6e04c6 => {
                    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::Release {
                        control_handle,
                    })
                }
                0xb41f1624f48c1e9 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5cde8914608d99b1 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x716b0af13d5c0806 => {
                    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 {payload: req,
                        control_handle,
                    })
                }
                0x5209c77415b4dfad => {
                    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,
                    })
                }
                0x5b3d0e51614df053 => {
                    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,
                        },
                    })
                }
                0x3a58e00157e0825 => {
                    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 {payload: req,
                        responder: BufferCollectionTokenGroupIsAlternateForResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x77d19a494b78ba8c => {
                    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::GetBufferCollectionId {
                        responder: BufferCollectionTokenGroupGetBufferCollectionIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x22dd3ea514eeffe1 => {
                    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::SetWeak {
                        control_handle,
                    })
                }
                0x38a44fc4d7724be9 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeSetWeakOkRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetWeakOkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::SetWeakOk {payload: req,
                        control_handle,
                    })
                }
                0x3f22f2a293d3cdac => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NodeAttachNodeTrackingRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeAttachNodeTrackingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BufferCollectionTokenGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BufferCollectionTokenGroupRequest::AttachNodeTracking {payload: req,
                        control_handle,
                    })
                }
                0x41a0075d419f30c5 => {
                    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,
                    })
                }
                0x15dea448c536070a => {
                    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 {payload: req,
                        responder: BufferCollectionTokenGroupCreateChildrenSyncResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5c327e4a23391312 => {
                    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,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(BufferCollectionTokenGroupRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionTokenGroupControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(BufferCollectionTokenGroupRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BufferCollectionTokenGroupControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BufferCollectionTokenGroupMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// The sysmem implementation is consistent with a logical / conceptual model of
/// allocation / logical allocation as follows:
///
/// As usual, a logical allocation considers either the root and all nodes with
/// connectivity to the root that don't transit a [`fuchsia.sysmem2/Node`]
/// created with [`fuchsia.sysmem2/BufferCollection.AttachToken`], or a subtree
/// rooted at an `AttachToken` `Node` and all `Node`(s) with connectivity to
/// that subtree that don't transit another `AttachToken`.  This is called the
/// logical allocation pruned subtree, or pruned subtree for short.
///
/// During constraints aggregation, each
/// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] will select a single child
/// `Node` among its direct 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 subtree, 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 will "hide" any other groups
/// under those non-selected children.
///
/// Within a logical allocation, aggregation is attempted first by provisionally
/// selecting 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 constraint 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;
/// if this is the pruned subtree rooted at the overall root `Node`) is
/// attempted once. If buffer allocation based on the first successful
/// constraints aggregation fails, the overall logical allocation fails (there
/// is no buffer allocation retry / re-attempt). If buffer allocation succeeds
/// (or is not needed due to being a pruned subtree that doesn't include the
/// root), the logical allocation succeeds.
///
/// If this prioritization scheme cannot reasonably work for your usage of
/// sysmem, please don't hesitate to 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.
/// Sysmem mitigates 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 [`fuchsia.sysmem2/ImageFormatConstraints`] in a
/// single [`fuchsia.sysmem2/BufferCollectionConstraints`] when feasible (when a
/// participant just needs to express the ability to work with more than a
/// single [`fuchsia.images2/PixelFormat`], with sysmem choosing which
/// `PixelFormat` to use among those supported by all participants).
///
/// Similar to [`fuchsia.sysmem2/BufferCollectionToken`] and
/// [`fuchsia.sysmem2/BufferCollection`], closure of the
/// `BufferCollectionTokenGroup` channel without sending
/// [`fuchsia.sysmem2/Node.Release`] first will cause buffer collection failure
/// (or subtree failure if using
/// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
/// [`fuchsia.sysmem2/BufferCollection.AttachToken`] and the
/// `BufferCollectionTokenGroup` is part of a subtree under such a node that
/// doesn't propagate failure to its parent).
///
/// Epitaphs are not used in this protocol.
#[derive(Debug)]
pub enum BufferCollectionTokenGroupRequest {
    /// Ensure that previous messages have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    Sync { responder: BufferCollectionTokenGroupSyncResponder },
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    Release { control_handle: BufferCollectionTokenGroupControlHandle },
    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    SetName { payload: NodeSetNameRequest, control_handle: BufferCollectionTokenGroupControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    SetDebugClientInfo {
        payload: NodeSetDebugClientInfoRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    SetDebugTimeoutLogDeadline {
        payload: NodeSetDebugTimeoutLogDeadlineRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    SetVerboseLogging { control_handle: BufferCollectionTokenGroupControlHandle },
    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    GetNodeRef { responder: BufferCollectionTokenGroupGetNodeRefResponder },
    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    IsAlternateFor {
        payload: NodeIsAlternateForRequest,
        responder: BufferCollectionTokenGroupIsAlternateForResponder,
    },
    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    GetBufferCollectionId { responder: BufferCollectionTokenGroupGetBufferCollectionIdResponder },
    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    SetWeak { control_handle: BufferCollectionTokenGroupControlHandle },
    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    SetWeakOk {
        payload: NodeSetWeakOkRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    AttachNodeTracking {
        payload: NodeAttachNodeTrackingRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Create a child [`fuchsia.sysmem2/BufferCollectionToken`]. Only one child
    /// (including its children) will be selected during allocation (or logical
    /// allocation).
    ///
    /// Before passing the client end of this token to
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], completion of
    /// [`fuchsia.sysmem2/Node.Sync`] after
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`] is required.
    /// Or the client can use
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChildrenSync`] which
    /// essentially includes the `Sync`.
    ///
    /// Sending CreateChild after AllChildrenPresent is not permitted; this will
    /// fail the group's subtree and close the connection.
    ///
    /// After all children have been created, send AllChildrenPresent.
    ///
    /// + request `token_request` The server end of the new token channel.
    /// + request `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. When the value isn't
    ///   ZX_RIGHT_SAME_RIGHTS, the value is interpretted as a bitmask with 0
    ///   bits ensuring those rights are attentuated, so 0xFFFFFFFF is a synonym
    ///   for ZX_RIGHT_SAME_RIGHTS. The value 0 is not allowed and intentionally
    ///   causes subtree failure.
    CreateChild {
        payload: BufferCollectionTokenGroupCreateChildRequest,
        control_handle: BufferCollectionTokenGroupControlHandle,
    },
    /// Create 1 or more child tokens at once, synchronously.  In contrast to
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`], no
    /// [`fuchsia.sysmem2/Node.Sync`] is required before passing the client end
    /// of a returned token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`].
    ///
    /// 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
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChild`] and
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.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.
    ///
    /// Sending CreateChildrenSync after AllChildrenPresent is not permitted;
    /// this will fail the group's subtree and close the connection.
    ///
    /// After all children have been created, send AllChildrenPresent.
    ///
    /// + request `rights_attentuation_masks` The size of the
    ///   `rights_attentuation_masks` determines the number of created child
    ///   tokens. The value ZX_RIGHT_SAME_RIGHTS doesn't attenuate any rights.
    ///   The value 0xFFFFFFFF is a synonym for ZX_RIGHT_SAME_RIGHTS. For any
    ///   other value, each 0 bit in the mask attenuates that right.
    /// - response `tokens` The created child tokens.
    CreateChildrenSync {
        payload: BufferCollectionTokenGroupCreateChildrenSyncRequest,
        responder: BufferCollectionTokenGroupCreateChildrenSyncResponder,
    },
    /// Indicate that no more children will be created.
    ///
    /// After creating all children, the client should send
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent`] to
    /// inform sysmem that no more children will be created, so that sysmem can
    /// know when it's ok to start aggregating constraints.
    ///
    /// Sending CreateChild after AllChildrenPresent is not permitted; this will
    /// fail the group's subtree and close the connection.
    ///
    /// If [`fuchsia.sysmem2/Node.Release`] is to be sent, it should be sent
    /// after `AllChildrenPresent`, else failure of the group's subtree will be
    /// triggered. This is intentionally not analogous to how `Release` without
    /// prior [`fuchsia.sysmem2/BufferCollection.SetConstraints`] doesn't cause
    /// subtree failure.
    AllChildrenPresent { control_handle: BufferCollectionTokenGroupControlHandle },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: BufferCollectionTokenGroupControlHandle,
        method_type: fidl::MethodType,
    },
}

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_release(self) -> Option<(BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::Release { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(NodeSetDebugTimeoutLogDeadlineRequest, BufferCollectionTokenGroupControlHandle)>
    {
        if let BufferCollectionTokenGroupRequest::SetDebugTimeoutLogDeadline {
            payload,
            control_handle,
        } = self
        {
            Some((payload, 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<(NodeIsAlternateForRequest, BufferCollectionTokenGroupIsAlternateForResponder)>
    {
        if let BufferCollectionTokenGroupRequest::IsAlternateFor { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_buffer_collection_id(
        self,
    ) -> Option<(BufferCollectionTokenGroupGetBufferCollectionIdResponder)> {
        if let BufferCollectionTokenGroupRequest::GetBufferCollectionId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_node_tracking(
        self,
    ) -> Option<(NodeAttachNodeTrackingRequest, BufferCollectionTokenGroupControlHandle)> {
        if let BufferCollectionTokenGroupRequest::AttachNodeTracking { payload, control_handle } =
            self
        {
            Some((payload, control_handle))
        } 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<(
        BufferCollectionTokenGroupCreateChildrenSyncRequest,
        BufferCollectionTokenGroupCreateChildrenSyncResponder,
    )> {
        if let BufferCollectionTokenGroupRequest::CreateChildrenSync { payload, responder } = self {
            Some((payload, 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::Release { .. } => "release",
            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::GetBufferCollectionId { .. } => {
                "get_buffer_collection_id"
            }
            BufferCollectionTokenGroupRequest::SetWeak { .. } => "set_weak",
            BufferCollectionTokenGroupRequest::SetWeakOk { .. } => "set_weak_ok",
            BufferCollectionTokenGroupRequest::AttachNodeTracking { .. } => "attach_node_tracking",
            BufferCollectionTokenGroupRequest::CreateChild { .. } => "create_child",
            BufferCollectionTokenGroupRequest::CreateChildrenSync { .. } => "create_children_sync",
            BufferCollectionTokenGroupRequest::AllChildrenPresent { .. } => "all_children_present",
            BufferCollectionTokenGroupRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            BufferCollectionTokenGroupRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

#[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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 payload: NodeGetNodeRefResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: NodeGetNodeRefResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BufferCollectionTokenGroupGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGroupGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGroupGetBufferCollectionIdResponder {
    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 BufferCollectionTokenGroupGetBufferCollectionIdResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: &NodeGetBufferCollectionIdResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: &NodeGetBufferCollectionIdResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[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 payload: BufferCollectionTokenGroupCreateChildrenSyncResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: BufferCollectionTokenGroupCreateChildrenSyncResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[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<NodeIsAlternateForResponse, Error>;

pub trait NodeProxyInterface: Send + Sync {
    type SyncResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#release(&self) -> Result<(), fidl::Error>;
    fn r#set_name(&self, payload: &NodeSetNameRequest) -> Result<(), fidl::Error>;
    fn r#set_debug_client_info(
        &self,
        payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_debug_timeout_log_deadline(
        &self,
        payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error>;
    fn r#set_verbose_logging(&self) -> Result<(), fidl::Error>;
    type GetNodeRefResponseFut: std::future::Future<Output = Result<NodeGetNodeRefResponse, 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,
        payload: NodeIsAlternateForRequest,
    ) -> Self::IsAlternateForResponseFut;
    type GetBufferCollectionIdResponseFut: std::future::Future<Output = Result<NodeGetBufferCollectionIdResponse, fidl::Error>>
        + Send;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut;
    fn r#set_weak(&self) -> Result<(), fidl::Error>;
    fn r#set_weak_ok(&self, payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error>;
    fn r#attach_node_tracking(
        &self,
        payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error>;
}

#[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.sysmem2/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 have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        NodeProxyInterface::r#sync(self)
    }

    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    pub fn r#release(&self) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#release(self)
    }

    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    pub fn r#set_name(&self, mut payload: &NodeSetNameRequest) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_name(self, payload)
    }

    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    pub fn r#set_debug_client_info(
        &self,
        mut payload: &NodeSetDebugClientInfoRequest,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_debug_client_info(self, payload)
    }

    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    pub fn r#set_debug_timeout_log_deadline(
        &self,
        mut payload: &NodeSetDebugTimeoutLogDeadlineRequest,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_debug_timeout_log_deadline(self, payload)
    }

    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    pub fn r#set_verbose_logging(&self) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_verbose_logging(self)
    }

    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    pub fn r#get_node_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_node_ref(self)
    }

    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    pub fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#is_alternate_for(self, payload)
    }

    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    pub fn r#get_buffer_collection_id(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_buffer_collection_id(self)
    }

    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    pub fn r#set_weak(&self) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_weak(self)
    }

    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    pub fn r#set_weak_ok(&self, mut payload: NodeSetWeakOkRequest) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#set_weak_ok(self, payload)
    }

    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    pub fn r#attach_node_tracking(
        &self,
        mut payload: NodeAttachNodeTrackingRequest,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#attach_node_tracking(self, payload)
    }
}

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::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x11ac2555cf575b54,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("sync")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

    type GetNodeRefResponseFut = fidl::client::QueryResponseFut<
        NodeGetNodeRefResponse,
        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<NodeGetNodeRefResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetNodeRefResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b3d0e51614df053,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("get_node_ref")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetNodeRefResponse>(
            (),
            0x5b3d0e51614df053,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type IsAlternateForResponseFut = fidl::client::QueryResponseFut<
        NodeIsAlternateForResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_alternate_for(
        &self,
        mut payload: NodeIsAlternateForRequest,
    ) -> 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::FlexibleResultType<NodeIsAlternateForResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a58e00157e0825,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("is_alternate_for")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeIsAlternateForRequest, NodeIsAlternateForResult>(
            &mut payload,
            0x3a58e00157e0825,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetBufferCollectionIdResponseFut = fidl::client::QueryResponseFut<
        NodeGetBufferCollectionIdResponse,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_buffer_collection_id(&self) -> Self::GetBufferCollectionIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetBufferCollectionIdResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<NodeGetBufferCollectionIdResponse>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x77d19a494b78ba8c,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("get_buffer_collection_id")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            NodeGetBufferCollectionIdResponse,
        >(
            (),
            0x77d19a494b78ba8c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(NodeEvent::_UnknownEvent { ordinal: 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.sysmem2/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 {
                    0x11ac2555cf575b54 => {
                        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,
                            },
                        })
                    }
                    0x6a5cae7d6d6e04c6 => {
                        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::Release { control_handle })
                    }
                    0xb41f1624f48c1e9 => {
                        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 { payload: req, control_handle })
                    }
                    0x5cde8914608d99b1 => {
                        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 { payload: req, control_handle })
                    }
                    0x716b0af13d5c0806 => {
                        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 { payload: req, control_handle })
                    }
                    0x5209c77415b4dfad => {
                        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 })
                    }
                    0x5b3d0e51614df053 => {
                        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,
                            },
                        })
                    }
                    0x3a58e00157e0825 => {
                        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 {
                            payload: req,
                            responder: NodeIsAlternateForResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x77d19a494b78ba8c => {
                        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::GetBufferCollectionId {
                            responder: NodeGetBufferCollectionIdResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x22dd3ea514eeffe1 => {
                        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::SetWeak { control_handle })
                    }
                    0x38a44fc4d7724be9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetWeakOkRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetWeakOkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetWeakOk { payload: req, control_handle })
                    }
                    0x3f22f2a293d3cdac => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeAttachNodeTrackingRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeAttachNodeTrackingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::AttachNodeTracking { payload: req, control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(NodeRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: NodeControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(NodeRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: NodeControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <NodeMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol is the parent protocol for all nodes in the tree established
/// by [`fuchsia.sysmem2/BufferCollectionToken`] creation and
/// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] creation, including
/// [`fuchsia.sysmem2/BufferCollectionToken`](s) which have since been converted
/// to a [`fuchsia.sysmem2/BufferCollection`] channel.
///
/// Epitaphs are not used in this protocol.
#[derive(Debug)]
pub enum NodeRequest {
    /// Ensure that previous messages have been received server side. This is
    /// particularly useful after previous messages that created new tokens,
    /// because a token must be known to the sysmem server before sending the
    /// token to another participant.
    ///
    /// Calling [`fuchsia.sysmem2/BufferCollectionToken.Sync`] on a token that
    /// isn't/wasn't a valid token risks the `Sync` stalling forever. See
    /// [`fuchsia.sysmem2/Allocator.ValidateBufferCollectionToken`] for one way
    /// to mitigate the possibility of a hostile/fake
    /// [`fuchsia.sysmem2/BufferCollectionToken`] at the cost of one round trip.
    /// Another way is to pass the token to
    /// [`fuchsia.sysmem2/Allocator/BindSharedCollection`], which also validates
    /// the token as part of exchanging it for a
    /// [`fuchsia.sysmem2/BufferCollection`] channel, and
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] can then be used without risk
    /// of stalling.
    ///
    /// After creating one or more [`fuchsia.sysmem2/BufferCollectionToken`](s)
    /// and then starting and completing a `Sync`, it's then safe to send the
    /// `BufferCollectionToken` client ends to other participants knowing the
    /// server will recognize the tokens when they're sent by the other
    /// participants to sysmem in a
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] message. This is an
    /// efficient way to create tokens while avoiding unnecessary round trips.
    ///
    /// Other options include waiting for each
    /// [`fuchsia.sysmem2/BufferCollectionToken.Duplicate`] to complete
    /// individually (using separate call to `Sync` after each), or calling
    /// [`fuchsia.sysmem2/BufferCollection.Sync`] after a token has been
    /// converted to a `BufferCollection` via
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`], or using
    /// [`fuchsia.sysmem2/BufferCollectionToken.DuplicateSync`] which includes
    /// the sync step and can create multiple tokens at once.
    Sync { responder: NodeSyncResponder },
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionToken`] channel:
    ///
    /// Normally a participant will convert a `BufferCollectionToken` into a
    /// [`fuchsia.sysmem2/BufferCollection`], but a participant can instead send
    /// `Release` via the token (and then close the channel immediately or
    /// shortly later in response to server closing the server end), which
    /// avoids causing buffer collection failure. Without a prior `Release`,
    /// closing the `BufferCollectionToken` client end will cause buffer
    /// collection failure.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollection`] channel:
    ///
    /// By default the server handles unexpected closure of a
    /// [`fuchsia.sysmem2/BufferCollection`] client end (without `Release`
    /// first) by failing the 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` without
    /// causing buffer collection failure, the participant can send `Release`
    /// before closing the `BufferCollection` client end. The `Release` 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, despite the lack of `BufferCollection` connection at the
    /// time of constraints aggregation.
    ///
    /// ###### On a [`fuchsia.sysmem2/BufferCollectionTokenGroup`] channel:
    ///
    /// By default, unexpected closure of a `BufferCollectionTokenGroup` client
    /// end (without `Release` first) will trigger failure of the buffer
    /// collection. To close a `BufferCollectionTokenGroup` channel without
    /// failing the buffer collection, ensure that AllChildrenPresent() has been
    /// sent, and send `Release` before closing the `BufferCollectionTokenGroup`
    /// client end.
    ///
    /// If `Release` occurs before
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup.AllChildrenPresent], the
    /// buffer collection will fail (triggered by reception of `Release` without
    /// prior `AllChildrenPresent`). This is intentionally not analogous to how
    /// [`fuchsia.sysmem2/BufferCollection.Release`] without
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] first doesn't cause
    /// buffer collection failure. For a `BufferCollectionTokenGroup`, clean
    /// close requires `AllChildrenPresent` (if not already sent), then
    /// `Release`, then close client end.
    ///
    /// If `Release` occurs after `AllChildrenPresent`, the children and all
    /// their constraints remain intact (just as they would if the
    /// `BufferCollectionTokenGroup` channel had remained open), and the client
    /// end close doesn't trigger buffer collection failure.
    ///
    /// ###### On all [`fuchsia.sysmem2/Node`] channels (any of the above):
    ///
    /// For brevity, the per-channel-protocol paragraphs above ignore the
    /// separate failure domain created by
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`] or
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`]. When a client end
    /// unexpectedly closes (without `Release` first) and that client end is
    /// under a failure domain, instead of failing the whole buffer collection,
    /// the failure domain is failed, but the buffer collection itself is
    /// isolated from failure of the failure domain. Such failure domains can be
    /// nested, in which case only the inner-most failure domain in which the
    /// `Node` resides fails.
    Release { control_handle: NodeControlHandle },
    /// Set a name for VMOs in this buffer collection.
    ///
    /// If the name doesn't fit in ZX_MAX_NAME_LEN, the name of the vmo itself
    /// will be truncated to fit. The name of the vmo will be suffixed with the
    /// buffer index within the collection (if the suffix fits within
    /// ZX_MAX_NAME_LEN). The name specified here (without truncation) will be
    /// listed in the inspect data.
    ///
    /// The name only affects VMOs allocated after the name is set; this call
    /// does not rename existing VMOs. If multiple clients set different names
    /// then the larger priority value will win. Setting a new name with the
    /// same priority as a prior name doesn't change the name.
    ///
    /// All table fields are currently required.
    ///
    /// + request `priority` The name is only set if this is the first `SetName`
    ///   or if `priority` is greater than any previous `priority` value in
    ///   prior `SetName` calls across all `Node`(s) of this buffer collection.
    /// + request `name` The name for VMOs created under this buffer collection.
    SetName { payload: NodeSetNameRequest, control_handle: NodeControlHandle },
    /// Set information about the current client that can be used by sysmem to
    /// help diagnose leaking memory and allocation stalls waiting for a
    /// participant to send [`fuchsia.sysmem2/BufferCollection.SetConstraints`].
    ///
    /// This sets the debug client info on this [`fuchsia.sysmem2/Node`] and all
    /// `Node`(s) derived from this `Node`, unless overriden by
    /// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] or a later
    /// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
    ///
    /// Sending [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] once per
    /// `Allocator` is the most efficient way to ensure that all
    /// [`fuchsia.sysmem2/Node`](s) will have at least some debug client info
    /// set, and is also more efficient than separately sending the same debug
    /// client info via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] for each
    /// created [`fuchsia.sysmem2/Node`].
    ///
    /// Also used when verbose logging is enabled (see `SetVerboseLogging`) to
    /// indicate which client is closing their channel first, leading to subtree
    /// failure (which can be normal if the purpose of the subtree 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).
    ///
    /// All table fields are currently required.
    ///
    /// + request `name` This can be an arbitrary string, but the current
    ///   process name (see `fsl::GetCurrentProcessName`) is a good default.
    /// + request `id` This can be an arbitrary id, but the current process ID
    ///   (see `fsl::GetCurrentProcessKoid`) is a good default.
    SetDebugClientInfo { payload: NodeSetDebugClientInfoRequest, control_handle: NodeControlHandle },
    /// Sysmem logs a warning if sysmem hasn't seen
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from all clients
    /// within 5 seconds after creation of a new 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.
    ///
    /// In most cases the default works well.
    ///
    /// All table fields are currently required.
    ///
    /// + request `deadline` The time at which sysmem will start trying to log
    ///   the warning, unless all constraints are with sysmem by then.
    SetDebugTimeoutLogDeadline {
        payload: NodeSetDebugTimeoutLogDeadlineRequest,
        control_handle: NodeControlHandle,
    },
    /// This enables verbose logging for the buffer collection.
    ///
    /// Verbose logging includes constraints set via
    /// [`fuchsia.sysmem2/BufferCollection.SetConstraints`] from each client
    /// along with info set via [`fuchsia.sysmem2/Node.SetDebugClientInfo`] (or
    /// [`fuchsia.sysmem2/Allocator.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 little surrounding context.  While this is often enough to diagnose
    /// a problem if only a small change was made and everything was 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
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`],
    /// [`fuchsia.sysmem2/BufferCollectionToken.SetDispensable`],
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`] nodes, and associated
    /// subtrees 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
    /// subtree is failing sooner than expected.
    ///
    /// The intent of the extra logging is to be acceptable from a performance
    /// point of view, under the assumption that verbose logging is only enabled
    /// on a low number of buffer collections. If we're not tracking down a bug,
    /// we shouldn't send this message.
    SetVerboseLogging { control_handle: NodeControlHandle },
    /// This gets a handle that can be used as a parameter to
    /// [`fuchsia.sysmem2/Node.IsAlternateFor`] called on any
    /// [`fuchsia.sysmem2/Node`]. This handle is only for use as proof that the
    /// client obtained this handle from this `Node`.
    ///
    /// Because this is a get not a set, no [`fuchsia.sysmem2/Node.Sync`] is
    /// needed between the `GetNodeRef` and the call to `IsAlternateFor`,
    /// despite the two calls typically being on different channels.
    ///
    /// See also [`fuchsia.sysmem2/Node.IsAlternateFor`].
    ///
    /// All table fields are currently required.
    ///
    /// - response `node_ref` This handle can be sent via `IsAlternateFor` on a
    ///   different `Node` channel, to prove that the client obtained the handle
    ///   from this `Node`.
    GetNodeRef { responder: NodeGetNodeRefResponder },
    /// Check whether the calling [`fuchsia.sysmem2/Node`] is in a subtree
    /// rooted at a different child token of a common parent
    /// [`fuchsia.sysmem2/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
    /// [`fuchsia.sysmem2/Node.GetNodeRef`].
    ///
    /// The `node_ref` can be a duplicated handle; it's not necessary to call
    /// `GetNodeRef` for every call to [`fuchsia.sysmem2/Node.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
    /// [`fuchsia.sysmem2/Allocator.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
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] with this token first
    /// which also validates the token along with converting it to a
    /// [`fuchsia.sysmem2/BufferCollection`], then call `IsAlternateFor`.
    ///
    /// All table fields are currently required.
    ///
    /// - response `is_alternate`
    ///   - 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 subtree 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
    ///     `Release`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 subtree other
    ///     than the subtree containing the calling `Node` or `node_ref` `Node`.
    /// * error `[fuchsia.sysmem2/Error.NOT_FOUND]` The node_ref wasn't
    ///   associated with the same buffer collection as the calling `Node`.
    ///   Another reason for this error is if the `node_ref` is an
    ///   [`zx.Handle.EVENT`] handle with sufficient rights, but isn't actually
    ///   a real `node_ref` obtained from `GetNodeRef`.
    /// * error `[fuchsia.sysmem2/Error.PROTOCOL_DEVIATION]` The caller passed a
    ///   `node_ref` that isn't a [`zx.Handle:EVENT`] 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.
    IsAlternateFor { payload: NodeIsAlternateForRequest, responder: NodeIsAlternateForResponder },
    /// Get the buffer collection ID. This ID is also available from
    /// [`fuchsia.sysmem2/Allocator.GetVmoInfo`] (along with the `buffer_index`
    /// within the collection).
    ///
    /// This call is mainly useful in situations where we can't convey a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] or
    /// [`fuchsia.sysmem2/BufferCollection`] directly, but can only convey a VMO
    /// handle, which can be joined back up with a `BufferCollection` client end
    /// that was created via a different path. Prefer to convey a
    /// `BufferCollectionToken` or `BufferCollection` directly when feasible.
    ///
    /// Trusting a `buffer_collection_id` value from a source other than sysmem
    /// is analogous to trusting a koid value from a source other than zircon.
    /// Both should be avoided unless really necessary, and both require
    /// caution. In some situations it may be reasonable to refer to a
    /// pre-established `BufferCollection` by `buffer_collection_id` via a
    /// protocol for efficiency reasons, but an incoming value purporting to be
    /// a `buffer_collection_id` is not sufficient alone to justify granting the
    /// sender of the `buffer_collection_id` any capability. The sender must
    /// first prove to a receiver that the sender has/had a VMO or has/had a
    /// `BufferCollectionToken` to the same collection by sending a handle that
    /// sysmem confirms is a valid sysmem handle and which sysmem maps to the
    /// `buffer_collection_id` value. The receiver should take care to avoid
    /// assuming that a sender had a `BufferCollectionToken` in cases where the
    /// sender has only proven that the sender had a VMO.
    ///
    /// - response `buffer_collection_id` This ID is unique per buffer
    ///   collection per boot. Each buffer is uniquely identified by the
    ///   `buffer_collection_id` and `buffer_index` together.
    GetBufferCollectionId { responder: NodeGetBufferCollectionIdResponder },
    /// Sets the current [`fuchsia.sysmem2/Node`] and all child `Node`(s)
    /// created after this message to weak, which means that a client's `Node`
    /// client end (or a child created after this message) is not alone
    /// sufficient to keep allocated VMOs alive.
    ///
    /// All VMOs obtained from weak `Node`(s) are weak sysmem VMOs. See also
    /// `close_weak_asap`.
    ///
    /// This message is only permitted before the `Node` becomes ready for
    /// allocation (else the server closes the channel with `ZX_ERR_BAD_STATE`):
    ///   * `BufferCollectionToken`: any time
    ///   * `BufferCollection`: before `SetConstraints`
    ///   * `BufferCollectionTokenGroup`: before `AllChildrenPresent`
    ///
    /// Currently, no conversion from strong `Node` to weak `Node` after ready
    /// for allocation is provided, but a client can simulate that by creating
    /// an additional `Node` before allocation and setting that additional
    /// `Node` to weak, and then potentially at some point later sending
    /// `Release` and closing the client end of the client's strong `Node`, but
    /// keeping the client's weak `Node`.
    ///
    /// Zero strong `Node`(s) and zero strong VMO handles will result in buffer
    /// collection failure (all `Node` client end(s) will see
    /// `ZX_CHANNEL_PEER_CLOSED` and all `close_weak_asap` `client_end`(s) will
    /// see `ZX_EVENTPAIR_PEER_CLOSED`), but sysmem (intentionally) won't notice
    /// this situation until all `Node`(s) are ready for allocation. For initial
    /// allocation to succeed, at least one strong `Node` is required to exist
    /// at allocation time, but after that client receives VMO handles, that
    /// client can `BufferCollection.Release` and close the client end without
    /// causing this type of failure.
    ///
    /// This implies [`fuchsia.sysmem2/Node.SetWeakOk`] as well, but does not
    /// imply `SetWeakOk` with `for_children_also` true, which can be sent
    /// separately as appropriate.
    SetWeak { control_handle: NodeControlHandle },
    /// This indicates to sysmem that the client is prepared to pay attention to
    /// `close_weak_asap`.
    ///
    /// If sent, this message must be before
    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
    ///
    /// All participants using a weak [`fuchsia.sysmem2/BufferCollection`] must
    /// send this message before `WaitForAllBuffersAllocated`, or a parent
    /// `Node` must have sent [`fuchsia.sysmem2/Node.SetWeakOk`] with
    /// `for_child_nodes_also` true, else the `WaitForAllBuffersAllocated` will
    /// trigger buffer collection failure.
    ///
    /// This message is necessary because weak sysmem VMOs have not always been
    /// a thing, so older clients are not aware of the need to pay attention to
    /// `close_weak_asap` `ZX_EVENTPAIR_PEER_CLOSED` and close all remaining
    /// sysmem weak VMO handles asap. By having this message and requiring
    /// participants to indicate their acceptance of this aspect of the overall
    /// protocol, we avoid situations where an older client is delivered a weak
    /// VMO without any way for sysmem to get that VMO to close quickly later
    /// (and on a per-buffer basis).
    ///
    /// A participant that doesn't handle `close_weak_asap` and also doesn't
    /// retrieve any VMO handles via `WaitForAllBuffersAllocated` doesn't need
    /// to send `SetWeakOk` (and doesn't need to have a parent `Node` send
    /// `SetWeakOk` with `for_child_nodes_also` true either). However, if that
    /// same participant has a child/delegate which does retrieve VMOs, that
    /// child/delegate will need to send `SetWeakOk` before
    /// `WaitForAllBuffersAllocated`.
    ///
    /// + request `for_child_nodes_also` If present and true, this means direct
    ///   child nodes of this node created after this message plus all
    ///   descendants of those nodes will behave as if `SetWeakOk` was sent on
    ///   those nodes. Any child node of this node that was created before this
    ///   message is not included. This setting is "sticky" in the sense that a
    ///   subsequent `SetWeakOk` without this bool set to true does not reset
    ///   the server-side bool. If this creates a problem for a participant, a
    ///   workaround is to `SetWeakOk` with `for_child_nodes_also` true on child
    ///   tokens instead, as appropriate. A participant should only set
    ///   `for_child_nodes_also` true if the participant can really promise to
    ///   obey `close_weak_asap` both for its own weak VMO handles, and for all
    ///   weak VMO handles held by participants holding the corresponding child
    ///   `Node`(s). When `for_child_nodes_also` is set, descendent `Node`(s)
    ///   which are using sysmem(1) can be weak, despite the clients of those
    ///   sysmem1 `Node`(s) not having any direct way to `SetWeakOk` or any
    ///   direct way to find out about `close_weak_asap`. This only applies to
    ///   descendents of this `Node` which are using sysmem(1), not to this
    ///   `Node` when converted directly from a sysmem2 token to a sysmem(1)
    ///   token, which will fail allocation unless an ancestor of this `Node`
    ///   specified `for_child_nodes_also` true.
    SetWeakOk { payload: NodeSetWeakOkRequest, control_handle: NodeControlHandle },
    /// The server_end will be closed after this `Node` and any child nodes have
    /// have released their buffer counts, making those counts available for
    /// reservation by a different `Node` via
    /// [`fuchsia.sysmem2/BufferCollection.AttachToken`].
    ///
    /// The `Node` buffer counts may not be released until the entire tree of
    /// `Node`(s) is closed or failed, because
    /// [`fuchsia.sysmem2/BufferCollection.Release`] followed by channel close
    /// does not immediately un-reserve the `Node` buffer counts. Instead, the
    /// `Node` buffer counts remain reserved until the orphaned node is later
    /// cleaned up.
    ///
    /// If the `Node` exceeds a fairly large number of attached eventpair server
    /// ends, a log message will indicate this and the `Node` (and the
    /// appropriate) sub-tree will fail.
    ///
    /// The `server_end` will remain open when
    /// [`fuchsia.sysmem2/Allocator.BindSharedCollection`] converts a
    /// [`fuchsia.sysmem2/BufferCollectionToken`] into a
    /// [`fuchsia.sysmem2/BufferCollection`].
    ///
    /// This message can also be used with a
    /// [`fuchsia.sysmem2/BufferCollectionTokenGroup`].
    AttachNodeTracking { payload: NodeAttachNodeTrackingRequest, control_handle: NodeControlHandle },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: NodeControlHandle,
        method_type: fidl::MethodType,
    },
}

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_release(self) -> Option<(NodeControlHandle)> {
        if let NodeRequest::Release { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_timeout_log_deadline(
        self,
    ) -> Option<(NodeSetDebugTimeoutLogDeadlineRequest, NodeControlHandle)> {
        if let NodeRequest::SetDebugTimeoutLogDeadline { payload, control_handle } = self {
            Some((payload, 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<(NodeIsAlternateForRequest, NodeIsAlternateForResponder)> {
        if let NodeRequest::IsAlternateFor { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_weak_ok(self) -> Option<(NodeSetWeakOkRequest, NodeControlHandle)> {
        if let NodeRequest::SetWeakOk { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_node_tracking(
        self,
    ) -> Option<(NodeAttachNodeTrackingRequest, NodeControlHandle)> {
        if let NodeRequest::AttachNodeTracking { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NodeRequest::Sync { .. } => "sync",
            NodeRequest::Release { .. } => "release",
            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",
            NodeRequest::GetBufferCollectionId { .. } => "get_buffer_collection_id",
            NodeRequest::SetWeak { .. } => "set_weak",
            NodeRequest::SetWeakOk { .. } => "set_weak_ok",
            NodeRequest::AttachNodeTracking { .. } => "attach_node_tracking",
            NodeRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            NodeRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

#[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::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x11ac2555cf575b54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 payload: NodeGetNodeRefResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: NodeGetNodeRefResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct NodeGetBufferCollectionIdResponder {
    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 NodeGetBufferCollectionIdResponder {
    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 NodeGetBufferCollectionIdResponder {
    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 NodeGetBufferCollectionIdResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: &NodeGetBufferCollectionIdResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        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 payload: &NodeGetBufferCollectionIdResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[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<SecureMemGetPhysicalSecureHeapsResponse, Error>;
pub type SecureMemGetDynamicSecureHeapsResult =
    Result<SecureMemGetDynamicSecureHeapsResponse, Error>;
pub type SecureMemGetPhysicalSecureHeapPropertiesResult =
    Result<SecureMemGetPhysicalSecureHeapPropertiesResponse, Error>;
pub type SecureMemAddSecureHeapPhysicalRangeResult = Result<(), Error>;
pub type SecureMemDeleteSecureHeapPhysicalRangeResult = Result<(), Error>;
pub type SecureMemModifySecureHeapPhysicalRangeResult = Result<(), Error>;
pub type SecureMemZeroSubRangeResult = Result<(), Error>;

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 GetDynamicSecureHeapsResponseFut: std::future::Future<Output = Result<SecureMemGetDynamicSecureHeapsResult, fidl::Error>>
        + Send;
    fn r#get_dynamic_secure_heaps(&self) -> Self::GetDynamicSecureHeapsResponseFut;
    type GetPhysicalSecureHeapPropertiesResponseFut: std::future::Future<
            Output = Result<SecureMemGetPhysicalSecureHeapPropertiesResult, fidl::Error>,
        > + Send;
    fn r#get_physical_secure_heap_properties(
        &self,
        payload: &SecureMemGetPhysicalSecureHeapPropertiesRequest,
    ) -> Self::GetPhysicalSecureHeapPropertiesResponseFut;
    type AddSecureHeapPhysicalRangeResponseFut: std::future::Future<Output = Result<SecureMemAddSecureHeapPhysicalRangeResult, fidl::Error>>
        + Send;
    fn r#add_secure_heap_physical_range(
        &self,
        payload: &SecureMemAddSecureHeapPhysicalRangeRequest,
    ) -> Self::AddSecureHeapPhysicalRangeResponseFut;
    type DeleteSecureHeapPhysicalRangeResponseFut: std::future::Future<
            Output = Result<SecureMemDeleteSecureHeapPhysicalRangeResult, fidl::Error>,
        > + Send;
    fn r#delete_secure_heap_physical_range(
        &self,
        payload: &SecureMemDeleteSecureHeapPhysicalRangeRequest,
    ) -> Self::DeleteSecureHeapPhysicalRangeResponseFut;
    type ModifySecureHeapPhysicalRangeResponseFut: std::future::Future<
            Output = Result<SecureMemModifySecureHeapPhysicalRangeResult, fidl::Error>,
        > + Send;
    fn r#modify_secure_heap_physical_range(
        &self,
        payload: &SecureMemModifySecureHeapPhysicalRangeRequest,
    ) -> Self::ModifySecureHeapPhysicalRangeResponseFut;
    type ZeroSubRangeResponseFut: std::future::Future<Output = Result<SecureMemZeroSubRangeResult, fidl::Error>>
        + Send;
    fn r#zero_sub_range(
        &self,
        payload: &SecureMemZeroSubRangeRequest,
    ) -> 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.sysmem2/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:
    ///  * PROTOCOL_DEVIATION - called more than once.
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    pub fn r#get_physical_secure_heaps(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#get_physical_secure_heaps(self)
    }

    /// Gets information about any secure heaps whose physical pages are not
    /// configured by the TEE, but by sysmem.
    ///
    /// Sysmem should only call this once. Returning zero heaps is not a
    /// failure.
    ///
    /// Errors:
    ///  * PROTOCOL_DEVIATION - called more than once.
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    pub fn r#get_dynamic_secure_heaps(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SecureMemGetDynamicSecureHeapsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#get_dynamic_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.
    ///
    /// Errors:
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    pub fn r#get_physical_secure_heap_properties(
        &self,
        mut payload: &SecureMemGetPhysicalSecureHeapPropertiesRequest,
    ) -> fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapPropertiesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#get_physical_secure_heap_properties(self, payload)
    }

    /// 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:
    ///   * PROTOCOL_DEVIATION - called more than once when
    ///     !dynamic_protection_ranges.  Adding a heap that would cause overall
    ///     heap count to exceed max_protected_range_count. Unexpected heap, or
    ///     range that doesn't conform to protected_range_granularity. See log.
    ///   * UNSPECIFIED - 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 failures.
    pub fn r#add_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemAddSecureHeapPhysicalRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        SecureMemAddSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#add_secure_heap_physical_range(self, payload)
    }

    /// 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:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     Unexpected heap, or range that doesn't conform to
    ///     protected_range_granularity.
    ///   * UNSPECIFIED - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of failures.
    pub fn r#delete_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemDeleteSecureHeapPhysicalRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        SecureMemDeleteSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#delete_secure_heap_physical_range(self, payload)
    }

    /// 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:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     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).
    ///   * UNSPECIFIED - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of failures.
    pub fn r#modify_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemModifySecureHeapPhysicalRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        SecureMemModifySecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#modify_secure_heap_physical_range(self, payload)
    }

    /// 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.
    ///
    /// Errors:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     Unexpected heap.
    ///   * UNSPECIFIED - 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 failures.
    pub fn r#zero_sub_range(
        &self,
        mut payload: &SecureMemZeroSubRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        SecureMemZeroSubRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SecureMemProxyInterface::r#zero_sub_range(self, payload)
    }
}

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::FlexibleResultType<SecureMemGetPhysicalSecureHeapsResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x38716300592073e3,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("get_physical_secure_heaps")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            SecureMemGetPhysicalSecureHeapsResult,
        >(
            (),
            0x38716300592073e3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetDynamicSecureHeapsResponseFut = fidl::client::QueryResponseFut<
        SecureMemGetDynamicSecureHeapsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_dynamic_secure_heaps(&self) -> Self::GetDynamicSecureHeapsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SecureMemGetDynamicSecureHeapsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SecureMemGetDynamicSecureHeapsResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1190847f99952834,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("get_dynamic_secure_heaps")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            SecureMemGetDynamicSecureHeapsResult,
        >(
            (),
            0x1190847f99952834,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetPhysicalSecureHeapPropertiesResponseFut = fidl::client::QueryResponseFut<
        SecureMemGetPhysicalSecureHeapPropertiesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_physical_secure_heap_properties(
        &self,
        mut payload: &SecureMemGetPhysicalSecureHeapPropertiesRequest,
    ) -> 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::FlexibleResultType<
                    SecureMemGetPhysicalSecureHeapPropertiesResponse,
                    Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0xc6f06889009c7bc,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("get_physical_secure_heap_properties")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemGetPhysicalSecureHeapPropertiesRequest,
            SecureMemGetPhysicalSecureHeapPropertiesResult,
        >(
            payload,
            0xc6f06889009c7bc,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type AddSecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemAddSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemAddSecureHeapPhysicalRangeRequest,
    ) -> 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::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x35f695b9b6c7217a,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("add_secure_heap_physical_range")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemAddSecureHeapPhysicalRangeRequest,
            SecureMemAddSecureHeapPhysicalRangeResult,
        >(
            payload,
            0x35f695b9b6c7217a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type DeleteSecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemDeleteSecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#delete_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemDeleteSecureHeapPhysicalRangeRequest,
    ) -> 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::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xeaa58c650264c9e,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("delete_secure_heap_physical_range")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemDeleteSecureHeapPhysicalRangeRequest,
            SecureMemDeleteSecureHeapPhysicalRangeResult,
        >(
            payload,
            0xeaa58c650264c9e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ModifySecureHeapPhysicalRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemModifySecureHeapPhysicalRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#modify_secure_heap_physical_range(
        &self,
        mut payload: &SecureMemModifySecureHeapPhysicalRangeRequest,
    ) -> 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::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x60b7448aa1187734,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("modify_secure_heap_physical_range")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SecureMemModifySecureHeapPhysicalRangeRequest,
            SecureMemModifySecureHeapPhysicalRangeResult,
        >(
            payload,
            0x60b7448aa1187734,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ZeroSubRangeResponseFut = fidl::client::QueryResponseFut<
        SecureMemZeroSubRangeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#zero_sub_range(
        &self,
        mut payload: &SecureMemZeroSubRangeRequest,
    ) -> 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::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b25b7901a385ce5,
            >(_buf?)?
            .into_result_fdomain::<SecureMemMarker>("zero_sub_range")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<SecureMemZeroSubRangeRequest, SecureMemZeroSubRangeResult>(
                payload,
                0x5b25b7901a385ce5,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _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 {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SecureMemEvent::_UnknownEvent { ordinal: 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.sysmem2/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 {
                    0x38716300592073e3 => {
                        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,
                            },
                        })
                    }
                    0x1190847f99952834 => {
                        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::GetDynamicSecureHeaps {
                            responder: SecureMemGetDynamicSecureHeapsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xc6f06889009c7bc => {
                        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 {
                            payload: req,
                            responder: SecureMemGetPhysicalSecureHeapPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35f695b9b6c7217a => {
                        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 {
                            payload: req,
                            responder: SecureMemAddSecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xeaa58c650264c9e => {
                        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 {
                            payload: req,
                            responder: SecureMemDeleteSecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x60b7448aa1187734 => {
                        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 {
                            payload: req,
                            responder: SecureMemModifySecureHeapPhysicalRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b25b7901a385ce5 => {
                        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 {
                            payload: req,
                            responder: SecureMemZeroSubRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(SecureMemRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SecureMemControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(SecureMemRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SecureMemControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => 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:
    ///  * PROTOCOL_DEVIATION - called more than once.
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    GetPhysicalSecureHeaps { responder: SecureMemGetPhysicalSecureHeapsResponder },
    /// Gets information about any secure heaps whose physical pages are not
    /// configured by the TEE, but by sysmem.
    ///
    /// Sysmem should only call this once. Returning zero heaps is not a
    /// failure.
    ///
    /// Errors:
    ///  * PROTOCOL_DEVIATION - called more than once.
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    GetDynamicSecureHeaps { responder: SecureMemGetDynamicSecureHeapsResponder },
    /// 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.
    ///
    /// Errors:
    ///  * UNSPECIFIED - 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 UNSPECIFIED.
    GetPhysicalSecureHeapProperties {
        payload: SecureMemGetPhysicalSecureHeapPropertiesRequest,
        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:
    ///   * PROTOCOL_DEVIATION - called more than once when
    ///     !dynamic_protection_ranges.  Adding a heap that would cause overall
    ///     heap count to exceed max_protected_range_count. Unexpected heap, or
    ///     range that doesn't conform to protected_range_granularity. See log.
    ///   * UNSPECIFIED - 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 failures.
    AddSecureHeapPhysicalRange {
        payload: SecureMemAddSecureHeapPhysicalRangeRequest,
        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:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     Unexpected heap, or range that doesn't conform to
    ///     protected_range_granularity.
    ///   * UNSPECIFIED - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of failures.
    DeleteSecureHeapPhysicalRange {
        payload: SecureMemDeleteSecureHeapPhysicalRangeRequest,
        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:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     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).
    ///   * UNSPECIFIED - generic internal error (such as in communication
    ///     with TEE which doesn't generate zx_status_t errors).
    ///   * NOT_FOUND - the specified range is not found.
    ///   * other errors are possible, such as from communication failures or
    ///     server propagation of failures.
    ModifySecureHeapPhysicalRange {
        payload: SecureMemModifySecureHeapPhysicalRangeRequest,
        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.
    ///
    /// Errors:
    ///   * PROTOCOL_DEVIATION - called when !dynamic_protection_ranges.
    ///     Unexpected heap.
    ///   * UNSPECIFIED - 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 failures.
    ZeroSubRange {
        payload: SecureMemZeroSubRangeRequest,
        responder: SecureMemZeroSubRangeResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: SecureMemControlHandle,
        method_type: fidl::MethodType,
    },
}

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_dynamic_secure_heaps(
        self,
    ) -> Option<(SecureMemGetDynamicSecureHeapsResponder)> {
        if let SecureMemRequest::GetDynamicSecureHeaps { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_zero_sub_range(
        self,
    ) -> Option<(SecureMemZeroSubRangeRequest, SecureMemZeroSubRangeResponder)> {
        if let SecureMemRequest::ZeroSubRange { payload, responder } = self {
            Some((payload, 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::GetDynamicSecureHeaps { .. } => "get_dynamic_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",
            SecureMemRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            SecureMemRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SecureMemGetDynamicSecureHeapsResponder {
    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 SecureMemGetDynamicSecureHeapsResponder {
    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 SecureMemGetDynamicSecureHeapsResponder {
    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 SecureMemGetDynamicSecureHeapsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&SecureMemGetDynamicSecureHeapsResponse, Error>,
    ) -> 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<&SecureMemGetDynamicSecureHeapsResponse, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AllocatorAllocateNonSharedCollectionRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AllocatorAllocateNonSharedCollectionRequest
    {
        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::<AllocatorAllocateNonSharedCollectionRequest>(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<BufferCollectionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.collection_request.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for AllocatorAllocateNonSharedCollectionRequest
    {
        #[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<BufferCollectionMarker>,
                > 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.collection_request.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<BufferCollectionMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AllocatorAllocateSharedCollectionRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AllocatorAllocateSharedCollectionRequest
    {
        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::<AllocatorAllocateSharedCollectionRequest>(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;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for AllocatorAllocateSharedCollectionRequest
    {
        #[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;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for AllocatorGetVmoInfoRequest {
        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 AllocatorGetVmoInfoRequest {
        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<
            AllocatorGetVmoInfoRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut AllocatorGetVmoInfoRequest
    {
        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::<AllocatorGetVmoInfoRequest>(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::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.vmo.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            BufferCollectionAttachLifetimeTrackingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionAttachLifetimeTrackingRequest
    {
        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::<BufferCollectionAttachLifetimeTrackingRequest>(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::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.server_end.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > 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.buffers_remaining
                    .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 BufferCollectionAttachLifetimeTrackingRequest
    {
        #[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::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.server_end.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _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.buffers_remaining.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(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            BufferCollectionAttachTokenRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionAttachTokenRequest
    {
        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::<BufferCollectionAttachTokenRequest>(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::Rights,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.rights_attenuation_mask
                    .as_ref()
                    .map(<fidl::Rights as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::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;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionAttachTokenRequest
    {
        #[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::Rights 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!(fidl::Rights, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    fidl::Rights,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::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;

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

            Ok(())
        }
    }

    impl BufferCollectionInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.buffer_collection_id {
                return 3;
            }
            if let Some(_) = self.buffers {
                return 2;
            }
            if let Some(_) = self.settings {
                return 1;
            }
            0
        }
    }

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

    unsafe impl
        fidl::encoding::Encode<BufferCollectionInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut BufferCollectionInfo
    {
        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::<BufferCollectionInfo>(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::<
                SingleBufferSettings,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.settings
                    .as_ref()
                    .map(<SingleBufferSettings as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionInfo
    {
        #[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 =
                    <SingleBufferSettings 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.settings.get_or_insert_with(|| {
                    fidl::new_empty!(
                        SingleBufferSettings,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    SingleBufferSettings,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for BufferCollectionSetConstraintsRequest {
        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 BufferCollectionSetConstraintsRequest {
        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<
            BufferCollectionSetConstraintsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionSetConstraintsRequest
    {
        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::<BufferCollectionSetConstraintsRequest>(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::<
                BufferCollectionConstraints,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.constraints
                    .as_ref()
                    .map(<BufferCollectionConstraints 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 BufferCollectionSetConstraintsRequest
    {
        #[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 =
                    <BufferCollectionConstraints 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.constraints.get_or_insert_with(|| {
                    fidl::new_empty!(
                        BufferCollectionConstraints,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    BufferCollectionConstraints,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            BufferCollectionTokenCreateBufferCollectionTokenGroupRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionTokenCreateBufferCollectionTokenGroupRequest
    {
        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::<BufferCollectionTokenCreateBufferCollectionTokenGroupRequest>(
                    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<BufferCollectionTokenGroupMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.group_request.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionTokenCreateBufferCollectionTokenGroupRequest
    {
        #[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<BufferCollectionTokenGroupMarker>,
                > 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.group_request.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<BufferCollectionTokenGroupMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            BufferCollectionTokenDuplicateRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BufferCollectionTokenDuplicateRequest
    {
        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::<BufferCollectionTokenDuplicateRequest>(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::Rights,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.rights_attenuation_mask
                    .as_ref()
                    .map(<fidl::Rights as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::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;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionTokenDuplicateRequest
    {
        #[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::Rights 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!(fidl::Rights, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    fidl::Rights,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::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;

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

            Ok(())
        }
    }

    impl 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::<
                fidl::Rights,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.rights_attenuation_mask
                    .as_ref()
                    .map(<fidl::Rights 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 =
                    <fidl::Rights 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!(fidl::Rights, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    fidl::Rights,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for BufferCollectionWaitForAllBuffersAllocatedResponse
    {
        #[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 =
                    <BufferCollectionInfo as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.buffer_collection_info.get_or_insert_with(|| {
                    fidl::new_empty!(
                        BufferCollectionInfo,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    BufferCollectionInfo,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for NodeAttachNodeTrackingRequest {
        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 NodeAttachNodeTrackingRequest {
        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<
            NodeAttachNodeTrackingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NodeAttachNodeTrackingRequest
    {
        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::<NodeAttachNodeTrackingRequest>(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::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.server_end.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeAttachNodeTrackingRequest
    {
        #[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::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.server_end.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NodeIsAlternateForRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NodeIsAlternateForRequest
    {
        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::<NodeIsAlternateForRequest>(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::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.node_ref.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeIsAlternateForRequest
    {
        #[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::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.node_ref.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for NodeSetWeakOkRequest {
        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 NodeSetWeakOkRequest {
        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<NodeSetWeakOkRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NodeSetWeakOkRequest
    {
        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::<NodeSetWeakOkRequest>(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::<
                bool,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.for_child_nodes_also
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeSetWeakOkRequest
    {
        #[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 =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.for_child_nodes_also.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<NodeGetNodeRefResponse, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NodeGetNodeRefResponse
    {
        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::<NodeGetNodeRefResponse>(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::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.node_ref.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeGetNodeRefResponse
    {
        #[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::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.node_ref.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl VmoBuffer {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.close_weak_asap {
                return 3;
            }
            if let Some(_) = self.vmo_usable_start {
                return 2;
            }
            if let Some(_) = self.vmo {
                return 1;
            }
            0
        }
    }

    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
    {
        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::<VmoBuffer>(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::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.vmo.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}