fdomain_fuchsia_io/

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

/// The type to identify a connection to a node.
/// It represents a capability: a reference to a node with associated rights.
pub type Token = fdomain_client::Event;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryCreateSymlinkRequest {
    pub name: String,
    pub target: Vec<u8>,
    pub connection: Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryDeprecatedOpenRequest {
    pub flags: OpenFlags,
    pub mode: ModeType,
    pub path: String,
    pub object: fdomain_client::fidl::ServerEnd<NodeMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryGetTokenResponse {
    pub s: i32,
    pub token: Option<fdomain_client::NullableHandle>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryLinkRequest {
    pub src: String,
    pub dst_parent_token: fdomain_client::NullableHandle,
    pub dst: String,
}

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

#[derive(Debug, PartialEq)]
pub struct DirectoryOpenRequest {
    pub path: String,
    pub flags: Flags,
    pub options: Options,
    pub object: fdomain_client::Channel,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryRenameRequest {
    pub src: String,
    pub dst_parent_token: fdomain_client::Event,
    pub dst: String,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryWatchRequest {
    pub mask: WatchMask,
    pub options: u32,
    pub watcher: fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileAllocateRequest {
    pub offset: u64,
    pub length: u64,
    /// If an empty bits is passed for mode, the default behavior is used. Otherwise the
    /// behavior is modified as described for each mode bit. If the backing filesystem doesn't
    /// support a particular provided mode bit, or combination of mode bits, an error is
    /// returned.
    pub mode: AllocateMode,
}

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

#[derive(Debug, PartialEq)]
pub struct FileEnableVerityRequest {
    pub options: VerificationOptions,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileObject {
    /// An optional event which transmits information about an object's readability
    /// or writability. This event relays information about the underlying object, not
    /// the capability granted to client: this event may be signalled "readable" on a
    /// connection that does not have the capability to read.
    ///
    /// The "`FILE_SIGNAL_`" values may be observed on this event.
    pub event: Option<fdomain_client::Event>,
    /// A placeholder for future stream support.
    ///
    /// Currently, servers are required not to send a handle in this field.
    pub stream: Option<fdomain_client::Stream>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileGetBackingMemoryResponse {
    pub vmo: fdomain_client::Vmo,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LinkableLinkIntoRequest {
    pub dst_parent_token: fdomain_client::Event,
    pub dst: String,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeDeprecatedCloneRequest {
    pub flags: OpenFlags,
    pub object: fdomain_client::fidl::ServerEnd<NodeMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeListExtendedAttributesRequest {
    pub iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeOnOpenRequest {
    pub s: i32,
    pub info: Option<Box<NodeInfoDeprecated>>,
}

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

#[derive(Debug, PartialEq)]
pub struct NodeSetExtendedAttributeRequest {
    pub name: Vec<u8>,
    pub value: ExtendedAttributeValue,
    /// Specifies the behavior based on the current state of the attribute.
    pub mode: SetExtendedAttributeMode,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ConnectionInfo {
    /// The rights possessed by the current connection. Note: `rights` limits
    /// the set of operations allowed on the connection, but does not guarantee
    /// their availability. For example, one may have the [`Rights.EXECUTE`]
    /// right on a file connection, but the file itself does not have the
    /// `EXECUTE` ability, and hence cannot be executed. See
    /// [`ConnectionOptions.rights`].
    pub rights: Option<Operations>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Auxiliary data for the file representation of a node.
#[derive(Debug, Default, PartialEq)]
pub struct FileInfo {
    /// True if the file is opened in append mode.
    /// In append mode, the seek offset is moved to the end before every
    /// write, the two steps performed in an atomic manner.
    pub is_append: Option<bool>,
    /// An optional event which transmits information about an object's
    /// readability or writability. This event relays information about the
    /// underlying object, not the capability granted to client: this event
    /// may be signalled "readable" on a connection that does not have
    /// the capability to read.
    ///
    /// This event will be present if the following conditions are met:
    ///
    /// - The `available_operations` on the file connection is not empty.
    /// - The filesystem supports signalling readability/writability events.
    ///
    /// The [`FileSignal`] values may be observed on this event.
    pub observer: Option<fdomain_client::Event>,
    /// An optional stream object, which can be used to read to and write from
    /// the file.
    ///
    /// Reading and writing the file using the stream object can be up to 20x
    /// faster than reading and writing the file using the Read and Write
    /// operations in the [`File`] protocol.
    pub stream: Option<fdomain_client::Stream>,
    /// Requested attributes for the file. This is only populated if requested.
    pub attributes: Option<NodeAttributes2>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The value type for an extended attribute. If the value is less than 32768
/// bytes, then it is included inline. Values larger than this size are written
/// into a vmo buffer.
#[derive(Debug)]
pub enum ExtendedAttributeValue {
    Bytes(Vec<u8>),
    Buffer(fdomain_client::Vmo),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `ExtendedAttributeValue` member.
#[macro_export]
macro_rules! ExtendedAttributeValueUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for ExtendedAttributeValue {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Bytes(x), Self::Bytes(y)) => *x == *y,
            (Self::Buffer(x), Self::Buffer(y)) => *x == *y,
            _ => false,
        }
    }
}

impl ExtendedAttributeValue {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Bytes(_) => 1,
            Self::Buffer(_) => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum NodeInfoDeprecated {
    /// No protocol information was supplied by the connection.
    Service(Service),
    /// The connection composes [`File`].
    File(FileObject),
    /// The connection composes [`Directory`].
    Directory(DirectoryObject),
    /// The connection composes ['Symlink'].
    Symlink(SymlinkObject),
}

impl NodeInfoDeprecated {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Service(_) => 1,
            Self::File(_) => 2,
            Self::Directory(_) => 3,
            Self::Symlink(_) => 4,
        }
    }
}

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

#[derive(Debug)]
pub enum Representation {
    /// The [`Node`] protocol was negotiated for this connection.
    Node(NodeInfo),
    /// The [`File`] protocol was negotiated for this connection.
    Directory(DirectoryInfo),
    /// The [`File`] protocol was negotiated for this connection.
    File(FileInfo),
    /// The [`Symlink`] protocol was negotiated for this connection.
    Symlink(SymlinkInfo),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `Representation` member.
#[macro_export]
macro_rules! RepresentationUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for Representation {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Node(x), Self::Node(y)) => *x == *y,
            (Self::Directory(x), Self::Directory(y)) => *x == *y,
            (Self::File(x), Self::File(y)) => *x == *y,
            (Self::Symlink(x), Self::Symlink(y)) => *x == *y,
            _ => false,
        }
    }
}

impl Representation {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Node(_) => 1,
            Self::Directory(_) => 2,
            Self::File(_) => 3,
            Self::Symlink(_) => 4,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

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

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

impl fdomain_client::fidl::ProtocolMarker for AdvisoryLockingMarker {
    type Proxy = AdvisoryLockingProxy;
    type RequestStream = AdvisoryLockingRequestStream;

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

pub trait AdvisoryLockingProxyInterface: Send + Sync {
    type AdvisoryLockResponseFut: std::future::Future<Output = Result<AdvisoryLockingAdvisoryLockResult, fidl::Error>>
        + Send;
    fn r#advisory_lock(&self, request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut;
}

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

impl fdomain_client::fidl::Proxy for AdvisoryLockingProxy {
    type Protocol = AdvisoryLockingMarker;

    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 AdvisoryLockingProxy {
    /// Create a new Proxy for fuchsia.io/AdvisoryLocking.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <AdvisoryLockingMarker 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) -> AdvisoryLockingEventStream {
        AdvisoryLockingEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    pub fn r#advisory_lock(
        &self,
        mut request: &AdvisoryLockRequest,
    ) -> fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        AdvisoryLockingProxyInterface::r#advisory_lock(self, request)
    }
}

impl AdvisoryLockingProxyInterface for AdvisoryLockingProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6ee9c0ad53ec87aa,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AdvisoryLockingAdvisoryLockRequest,
            AdvisoryLockingAdvisoryLockResult,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl AdvisoryLockingEvent {
    /// Decodes a message buffer as a [`AdvisoryLockingEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<AdvisoryLockingEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <AdvisoryLockingMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for AdvisoryLockingRequestStream {
    type Protocol = AdvisoryLockingMarker;
    type ControlHandle = AdvisoryLockingControlHandle;

    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 {
        AdvisoryLockingControlHandle { 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 AdvisoryLockingRequestStream {
    type Item = Result<AdvisoryLockingRequest, 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 AdvisoryLockingRequestStream 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 {
                0x6ee9c0ad53ec87aa => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AdvisoryLockingAdvisoryLockRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AdvisoryLockingAdvisoryLockRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AdvisoryLockingControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AdvisoryLockingRequest::AdvisoryLock {request: req.request,

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

/// Advisory locking protocol.
///
/// This protocol is intended to be composed into the |File| protocol to
/// provide support for advisory locking.
///
/// Advisory locks are purely advisory. They do not prevent actual read or
/// write operations from occurring on the file, either through this
/// connection or through other connections.
///
/// These primitives are designed to support the flock() and fcntl(),
/// specifically F_SETLK, F_SETLKW, and F_GETLK, functionality that code
/// running on Fuchsia expects from other operating systems.
#[derive(Debug)]
pub enum AdvisoryLockingRequest {
    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    AdvisoryLock { request: AdvisoryLockRequest, responder: AdvisoryLockingAdvisoryLockResponder },
}

impl AdvisoryLockingRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_advisory_lock(
        self,
    ) -> Option<(AdvisoryLockRequest, AdvisoryLockingAdvisoryLockResponder)> {
        if let AdvisoryLockingRequest::AdvisoryLock { request, responder } = self {
            Some((request, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for AdvisoryLockingControlHandle {
    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 AdvisoryLockingControlHandle {}

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for DirectoryMarker {
    type Proxy = DirectoryProxy;
    type RequestStream = DirectoryRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.io.Directory";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for DirectoryMarker {}
pub type DirectoryUnlinkResult = Result<(), i32>;
pub type DirectoryRenameResult = Result<(), i32>;
pub type DirectoryCreateSymlinkResult = Result<(), i32>;

pub trait DirectoryProxyInterface: Send + Sync {
    type AdvisoryLockResponseFut: std::future::Future<Output = Result<AdvisoryLockingAdvisoryLockResult, fidl::Error>>
        + Send;
    fn r#advisory_lock(&self, request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut;
    fn r#clone(
        &self,
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    fn r#deprecated_clone(
        &self,
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type DeprecatedGetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut;
    type DeprecatedSetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#deprecated_set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut;
    type DeprecatedGetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut;
    type DeprecatedSetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#deprecated_set_flags(&self, flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<NodeGetFlagsResult, fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<NodeSetFlagsResult, fidl::Error>>
        + Send;
    fn r#set_flags(&self, flags: Flags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetAttributesResponseFut: std::future::Future<Output = Result<NodeGetAttributesResult, fidl::Error>>
        + Send;
    fn r#get_attributes(&self, query: NodeAttributesQuery) -> Self::GetAttributesResponseFut;
    type UpdateAttributesResponseFut: std::future::Future<Output = Result<NodeUpdateAttributesResult, fidl::Error>>
        + Send;
    fn r#update_attributes(
        &self,
        payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut;
    type SyncResponseFut: std::future::Future<Output = Result<NodeSyncResult, fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#list_extended_attributes(
        &self,
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type GetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeGetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#get_extended_attribute(&self, name: &[u8]) -> Self::GetExtendedAttributeResponseFut;
    type SetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeSetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#set_extended_attribute(
        &self,
        name: &[u8],
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut;
    type RemoveExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeRemoveExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#remove_extended_attribute(&self, name: &[u8]) -> Self::RemoveExtendedAttributeResponseFut;
    fn r#deprecated_open(
        &self,
        flags: OpenFlags,
        mode: ModeType,
        path: &str,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#open(
        &self,
        path: &str,
        flags: Flags,
        options: &Options,
        object: fdomain_client::Channel,
    ) -> Result<(), fidl::Error>;
    type ReadDirentsResponseFut: std::future::Future<Output = Result<(i32, Vec<u8>), fidl::Error>>
        + Send;
    fn r#read_dirents(&self, max_bytes: u64) -> Self::ReadDirentsResponseFut;
    type RewindResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#rewind(&self) -> Self::RewindResponseFut;
    type GetTokenResponseFut: std::future::Future<
            Output = Result<(i32, Option<fdomain_client::NullableHandle>), fidl::Error>,
        > + Send;
    fn r#get_token(&self) -> Self::GetTokenResponseFut;
    type LinkResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#link(
        &self,
        src: &str,
        dst_parent_token: fdomain_client::NullableHandle,
        dst: &str,
    ) -> Self::LinkResponseFut;
    type UnlinkResponseFut: std::future::Future<Output = Result<DirectoryUnlinkResult, fidl::Error>>
        + Send;
    fn r#unlink(&self, name: &str, options: &UnlinkOptions) -> Self::UnlinkResponseFut;
    type RenameResponseFut: std::future::Future<Output = Result<DirectoryRenameResult, fidl::Error>>
        + Send;
    fn r#rename(
        &self,
        src: &str,
        dst_parent_token: fdomain_client::Event,
        dst: &str,
    ) -> Self::RenameResponseFut;
    type CreateSymlinkResponseFut: std::future::Future<Output = Result<DirectoryCreateSymlinkResult, fidl::Error>>
        + Send;
    fn r#create_symlink(
        &self,
        name: &str,
        target: &[u8],
        connection: Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
    ) -> Self::CreateSymlinkResponseFut;
    type WatchResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#watch(
        &self,
        mask: WatchMask,
        options: u32,
        watcher: fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
    ) -> Self::WatchResponseFut;
}

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

impl fdomain_client::fidl::Proxy for DirectoryProxy {
    type Protocol = DirectoryMarker;

    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 DirectoryProxy {
    /// Create a new Proxy for fuchsia.io/Directory.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <DirectoryMarker 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) -> DirectoryEventStream {
        DirectoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    pub fn r#advisory_lock(
        &self,
        mut request: &AdvisoryLockRequest,
    ) -> fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#advisory_lock(self, request)
    }

    pub fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#query(self)
    }

    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    pub fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#deprecated_clone(self, flags, object)
    }

    /// DEPRECATED - Use `Node.GetAttributes` instead.
    pub fn r#deprecated_get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#deprecated_get_attr(self)
    }

    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    pub fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#deprecated_set_attr(self, flags, attributes)
    }

    /// [DEPRECATED - Use new GetFlags method instead.]
    pub fn r#deprecated_get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#deprecated_get_flags(self)
    }

    /// [DEPRECATED - Use new SetFlags method instead.]
    pub fn r#deprecated_set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#deprecated_set_flags(self, flags)
    }

    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#get_flags(self)
    }

    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    pub fn r#set_flags(
        &self,
        mut flags: Flags,
    ) -> fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#set_flags(self, flags)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_attributes(
        &self,
        mut query: NodeAttributesQuery,
    ) -> fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#get_attributes(self, query)
    }

    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#update_attributes(self, payload)
    }

    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<NodeSyncResult, fdomain_client::fidl::FDomainResourceDialect>
    {
        DirectoryProxyInterface::r#sync(self)
    }

    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#list_extended_attributes(self, iterator)
    }

    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#get_extended_attribute(self, name)
    }

    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#set_extended_attribute(self, name, value, mode)
    }

    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#remove_extended_attribute(self, name)
    }

    /// DEPRECATED - Use `fuchsia.io/Directory.Open` instead.
    pub fn r#deprecated_open(
        &self,
        mut flags: OpenFlags,
        mut mode: ModeType,
        mut path: &str,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#deprecated_open(self, flags, mode, path, object)
    }

    /// Open (or create) a node relative to this directory. Any errors are communicated via an
    /// epitaph sent on the `object` channel.
    ///
    /// Errors:
    /// * `ZX_ERR_BAD_PATH` if `path` is invalid
    /// * See [`Flags`] for other errors which may be communicated based on `flags`
    pub fn r#open(
        &self,
        mut path: &str,
        mut flags: Flags,
        mut options: &Options,
        mut object: fdomain_client::Channel,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#open(self, path, flags, options, object)
    }

    /// Reads a collection of variably sized dirents into a buffer.
    /// The number of dirents in a directory may be very large: akin to
    /// calling read multiple times on a file, directories have a seek
    /// offset which is updated on subsequent calls to ReadDirents.
    /// Each call to ReadDirents will only return whole dirent structures,
    /// they will not get split across ReadDirent calls. When the seek
    /// offset reaches the end, `dirents` will be empty.
    ///
    /// These dirents are of the form:
    /// ```
    /// struct dirent {
    ///   // Describes the inode of the entry.
    ///   uint64 ino;
    ///   // Describes the length of the dirent name in bytes.
    ///   uint8 size;
    ///   // Describes the type of the entry. Aligned with the
    ///   // POSIX d_type values. Use `DirentType` constants.
    ///   uint8 type;
    ///   // Unterminated name of entry.
    ///   char name[0];
    /// }
    /// ```
    ///
    /// This method does not require any rights, since one could always probe for
    /// directory contents by triggering name conflicts during file creation.
    pub fn r#read_dirents(
        &self,
        mut max_bytes: u64,
    ) -> fidl::client::QueryResponseFut<(i32, Vec<u8>), fdomain_client::fidl::FDomainResourceDialect>
    {
        DirectoryProxyInterface::r#read_dirents(self, max_bytes)
    }

    /// Resets the directory seek offset.
    ///
    /// This method does not require any rights, similar to ReadDirents.
    pub fn r#rewind(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#rewind(self)
    }

    /// Acquires a token to a Directory which can be used to identify access to it at a later point
    /// in time. The token will remain valid for as long as the connection requesting the token
    /// remains open.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#get_token(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<fdomain_client::NullableHandle>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#get_token(self)
    }

    /// Creates a link to an object named src by the name dst, within a directory represented by
    /// token.
    ///
    /// `src` must be a resolved object name. Including "/" in the string will
    /// return `ZX_ERR_INVALID_ARGS`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will
    /// return `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and
    /// `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.
    ///
    /// This will be atomic with respect to renaming or unlinking the source concurrently e.g. if
    /// there are two actors operating concurrently, and one actor performs a rename that affects
    /// the source within this directory, and the other does a link, each will appear to occur
    /// atomically in an unspecified order.
    pub fn r#link(
        &self,
        mut src: &str,
        mut dst_parent_token: fdomain_client::NullableHandle,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#link(self, src, dst_parent_token, dst)
    }

    /// Removes a child node from the this directory's list of entries.
    ///
    /// Note: this does not guarantee that the underlying object is destroyed.
    /// Although the link will be removed from the containing directory,
    /// objects with multiple references (such as files which are still open)
    /// will not actually be destroyed until all references are closed.
    ///
    /// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
    ///   [`Rights.WRITE_BYTES`].
    /// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
    ///   support writing.
    /// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
    /// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
    /// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
    ///   containing a remote channel.
    /// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
    ///     something other than a directory was found.
    ///
    /// Other errors may be returned for filesystem-specific reasons.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.MODIFY_DIRECTORY`]
    pub fn r#unlink(
        &self,
        mut name: &str,
        mut options: &UnlinkOptions,
    ) -> fidl::client::QueryResponseFut<
        DirectoryUnlinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#unlink(self, name, options)
    }

    /// Renames a node named `src` to the name `dst`, in a directory represented
    /// by `dst_parent_token`.
    ///
    /// `src` and `dst` must be valid node names.
    /// See [`Name`] for what constitutes a valid name.
    ///
    /// This method requires the following rights on both the current connection, and the connection
    /// identified by `dst_parent_token`:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.MODIFY_DIRECTORY`]
    ///
    /// The following requirements are necessary to avoid rights escalations.
    ///
    /// If the source and destination directory differ, the source directory must also have the
    /// maximal set of abilities supported for files, which would typically be
    /// [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and
    /// [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]
    /// right.
    ///
    /// If `src` refers to a directory, and differs from the destination directory, then the source
    /// directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.
    ///
    /// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
    /// * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.
    pub fn r#rename(
        &self,
        mut src: &str,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        DirectoryRenameResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#rename(self, src, dst_parent_token, dst)
    }

    /// Creates a symbolic link.
    ///
    /// `name` is the name to be given to the created symbolic link.
    /// `target` is the target of the symbolic link, which has no meaning on the server. The server
    /// will perform no validation of `target` except for a server chosen maximum length.
    /// `connection` is an optional server end of a channel that will speak the Symlink protocol
    /// on the successfully created node.
    ///
    /// * [`Rights.MODIFY_DIRECTORY`]
    ///
    /// * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.
    /// * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.
    /// * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].
    /// * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.
    pub fn r#create_symlink(
        &self,
        mut name: &str,
        mut target: &[u8],
        mut connection: Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
    ) -> fidl::client::QueryResponseFut<
        DirectoryCreateSymlinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DirectoryProxyInterface::r#create_symlink(self, name, target, connection)
    }

    /// Watches a directory, receiving events of added messages on the
    /// watcher request channel.
    ///
    /// Options must be zero; it is reserved.
    ///
    /// This method does not require any rights, similar to ReadDirents.
    pub fn r#watch(
        &self,
        mut mask: WatchMask,
        mut options: u32,
        mut watcher: fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        DirectoryProxyInterface::r#watch(self, mask, options, watcher)
    }
}

impl DirectoryProxyInterface for DirectoryProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6ee9c0ad53ec87aa,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AdvisoryLockingAdvisoryLockRequest,
            AdvisoryLockingAdvisoryLockResult,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fdomain_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fdomain_fuchsia_unknown::QueryableQueryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeDeprecatedCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type DeprecatedGetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x78985e216314dafd,
            >(_buf?)?;
            Ok((_response.s, _response.attributes))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, NodeAttributes)>(
            (),
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedGetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b88fffb8eda3aa1,
            >(_buf?)?;
            Ok((_response.s, _response.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, OpenFlags)>(
            (),
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_flags(&self, mut flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x176eb318f64ec23,
            >(_buf?)?
            .into_result_fdomain::<DirectoryMarker>("get_flags")?;
            Ok(_response.map(|x| x.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetFlagsResult>(
            (),
            0x176eb318f64ec23,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_flags(&self, mut flags: Flags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x55a8028685791ea8,
            >(_buf?)?
            .into_result_fdomain::<DirectoryMarker>("set_flags")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, NodeSetFlagsResult>(
            (flags,),
            0x55a8028685791ea8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6f344a1c6b0a0610,
            >(_buf?)?;
            Ok((_response.s, _response.info))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<FilesystemInfo>>),
        >(
            (),
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3d4396a638ea053b,
            >(_buf?)?;
            Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
        }
        self.client.send_query_and_decode::<NodeGetAttributesRequest, NodeGetAttributesResult>(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3308c1da5a89bf08,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MutableNodeAttributes, NodeUpdateAttributesResult>(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SyncResponseFut = fidl::client::QueryResponseFut<
        NodeSyncResult,
        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<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c5c27ca0ab5dc49,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeSyncResult>(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x45ffa3ccfdeb76db,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeGetExtendedAttributeRequest,
            NodeGetExtendedAttributeResult,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4a951362f681f23c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeSetExtendedAttributeRequest,
            NodeSetExtendedAttributeResult,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7a0b9f3a9bf9032d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeRemoveExtendedAttributeRequest,
            NodeRemoveExtendedAttributeResult,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#deprecated_open(
        &self,
        mut flags: OpenFlags,
        mut mode: ModeType,
        mut path: &str,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryDeprecatedOpenRequest>(
            (flags, mode, path, object),
            0x2c5044561d685ec0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    fn r#open(
        &self,
        mut path: &str,
        mut flags: Flags,
        mut options: &Options,
        mut object: fdomain_client::Channel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryOpenRequest>(
            (path, flags, options, object),
            0x568ddcb9a9cbb6d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadDirentsResponseFut = fidl::client::QueryResponseFut<
        (i32, Vec<u8>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#read_dirents(&self, mut max_bytes: u64) -> Self::ReadDirentsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryReadDirentsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3582806bf27faa0a,
            >(_buf?)?;
            Ok((_response.s, _response.dirents))
        }
        self.client.send_query_and_decode::<DirectoryReadDirentsRequest, (i32, Vec<u8>)>(
            (max_bytes,),
            0x3582806bf27faa0a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type GetTokenResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<fdomain_client::NullableHandle>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_token(&self) -> Self::GetTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fdomain_client::NullableHandle>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryGetTokenResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x26ae9d18763c8655,
            >(_buf?)?;
            Ok((_response.s, _response.token))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<fdomain_client::NullableHandle>),
        >(
            (),
            0x26ae9d18763c8655,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type LinkResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#link(
        &self,
        mut src: &str,
        mut dst_parent_token: fdomain_client::NullableHandle,
        mut dst: &str,
    ) -> Self::LinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryLinkResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x740604c0c7c930e7,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<DirectoryLinkRequest, i32>(
            (src, dst_parent_token, dst),
            0x740604c0c7c930e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnlinkResponseFut = fidl::client::QueryResponseFut<
        DirectoryUnlinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#unlink(&self, mut name: &str, mut options: &UnlinkOptions) -> Self::UnlinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DirectoryUnlinkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x750a0326a78d7bed,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DirectoryUnlinkRequest, DirectoryUnlinkResult>(
            (name, options),
            0x750a0326a78d7bed,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RenameResponseFut = fidl::client::QueryResponseFut<
        DirectoryRenameResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#rename(
        &self,
        mut src: &str,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> Self::RenameResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DirectoryRenameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7060e7723b9928de,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DirectoryRenameRequest, DirectoryRenameResult>(
            (src, dst_parent_token, dst),
            0x7060e7723b9928de,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateSymlinkResponseFut = fidl::client::QueryResponseFut<
        DirectoryCreateSymlinkResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_symlink(
        &self,
        mut name: &str,
        mut target: &[u8],
        mut connection: Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
    ) -> Self::CreateSymlinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DirectoryCreateSymlinkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x21ce0f19ec043889,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DirectoryCreateSymlinkRequest, DirectoryCreateSymlinkResult>(
                (name, target, connection),
                0x21ce0f19ec043889,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WatchResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#watch(
        &self,
        mut mask: WatchMask,
        mut options: u32,
        mut watcher: fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
    ) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryWatchResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5717193a59d66d91,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<DirectoryWatchRequest, i32>(
            (mask, options, watcher),
            0x5717193a59d66d91,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum DirectoryEvent {
    OnOpen_ {
        s: i32,
        info: Option<Box<NodeInfoDeprecated>>,
    },
    OnRepresentation {
        payload: Representation,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl DirectoryEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_open_(self) -> Option<(i32, Option<Box<NodeInfoDeprecated>>)> {
        if let DirectoryEvent::OnOpen_ { s, info } = self { Some((s, info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_representation(self) -> Option<Representation> {
        if let DirectoryEvent::OnRepresentation { payload } = self { Some((payload)) } else { None }
    }

    /// Decodes a message buffer as a [`DirectoryEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DirectoryEvent, 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 {
            0x7fc7bbb1dbfd1972 => {
                let mut out = fidl::new_empty!(
                    NodeOnOpenRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeOnOpenRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DirectoryEvent::OnOpen_ { s: out.s, info: out.info }))
            }
            0x5cb40567d80a510c => {
                let mut out =
                    fidl::new_empty!(Representation, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<Representation>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DirectoryEvent::OnRepresentation { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(DirectoryEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <DirectoryMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for DirectoryRequestStream {
    type Protocol = DirectoryMarker;
    type ControlHandle = DirectoryControlHandle;

    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 {
        DirectoryControlHandle { 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 DirectoryRequestStream {
    type Item = Result<DirectoryRequest, 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 DirectoryRequestStream 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 {
                    0x6ee9c0ad53ec87aa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AdvisoryLockingAdvisoryLockRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AdvisoryLockingAdvisoryLockRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::AdvisoryLock {
                            request: req.request,

                            responder: DirectoryAdvisoryLockResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fdomain_fuchsia_unknown::CloneableCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Close {
                            responder: DirectoryCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Query {
                            responder: DirectoryQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a61678f293ce16f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedClone {
                            flags: req.flags,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x78985e216314dafd => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedGetAttr {
                            responder: DirectoryDeprecatedGetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4186c0f40d938f46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetAttrRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedSetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: DirectoryDeprecatedSetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b88fffb8eda3aa1 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedGetFlags {
                            responder: DirectoryDeprecatedGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedSetFlags {
                            flags: req.flags,

                            responder: DirectoryDeprecatedSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x176eb318f64ec23 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetFlags {
                            responder: DirectoryGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55a8028685791ea8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::SetFlags {
                            flags: req.flags,

                            responder: DirectorySetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f344a1c6b0a0610 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::QueryFilesystem {
                            responder: DirectoryQueryFilesystemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d4396a638ea053b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetAttributes {
                            query: req.query,

                            responder: DirectoryGetAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3308c1da5a89bf08 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MutableNodeAttributes,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MutableNodeAttributes>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::UpdateAttributes {
                            payload: req,
                            responder: DirectoryUpdateAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c5c27ca0ab5dc49 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Sync {
                            responder: DirectorySyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4b61033de007fcd0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeListExtendedAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeListExtendedAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::ListExtendedAttributes {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x45ffa3ccfdeb76db => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetExtendedAttribute {
                            name: req.name,

                            responder: DirectoryGetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a951362f681f23c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::SetExtendedAttribute {
                            name: req.name,
                            value: req.value,
                            mode: req.mode,

                            responder: DirectorySetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a0b9f3a9bf9032d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeRemoveExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeRemoveExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::RemoveExtendedAttribute {
                            name: req.name,

                            responder: DirectoryRemoveExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c5044561d685ec0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryDeprecatedOpenRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryDeprecatedOpenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::DeprecatedOpen {
                            flags: req.flags,
                            mode: req.mode,
                            path: req.path,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x568ddcb9a9cbb6d9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryOpenRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryOpenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Open {
                            path: req.path,
                            flags: req.flags,
                            options: req.options,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x3582806bf27faa0a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryReadDirentsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryReadDirentsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::ReadDirents {
                            max_bytes: req.max_bytes,

                            responder: DirectoryReadDirentsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x16b1202af0f34c71 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Rewind {
                            responder: DirectoryRewindResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x26ae9d18763c8655 => {
                        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 = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetToken {
                            responder: DirectoryGetTokenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x740604c0c7c930e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryLinkRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryLinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Link {
                            src: req.src,
                            dst_parent_token: req.dst_parent_token,
                            dst: req.dst,

                            responder: DirectoryLinkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x750a0326a78d7bed => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryUnlinkRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryUnlinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Unlink {
                            name: req.name,
                            options: req.options,

                            responder: DirectoryUnlinkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7060e7723b9928de => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryRenameRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryRenameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Rename {
                            src: req.src,
                            dst_parent_token: req.dst_parent_token,
                            dst: req.dst,

                            responder: DirectoryRenameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21ce0f19ec043889 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryCreateSymlinkRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryCreateSymlinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::CreateSymlink {
                            name: req.name,
                            target: req.target,
                            connection: req.connection,

                            responder: DirectoryCreateSymlinkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5717193a59d66d91 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryWatchRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DirectoryWatchRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Watch {
                            mask: req.mask,
                            options: req.options,
                            watcher: req.watcher,

                            responder: DirectoryWatchResponder {
                                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(DirectoryRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: DirectoryControlHandle { 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(DirectoryRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: DirectoryControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DirectoryMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Directory defines a node which is capable of containing other Objects.
#[derive(Debug)]
pub enum DirectoryRequest {
    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    AdvisoryLock {
        request: AdvisoryLockRequest,
        responder: DirectoryAdvisoryLockResponder,
    },
    Clone {
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: DirectoryCloseResponder,
    },
    Query {
        responder: DirectoryQueryResponder,
    },
    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    DeprecatedClone {
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// DEPRECATED - Use `Node.GetAttributes` instead.
    DeprecatedGetAttr {
        responder: DirectoryDeprecatedGetAttrResponder,
    },
    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    DeprecatedSetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: DirectoryDeprecatedSetAttrResponder,
    },
    /// [DEPRECATED - Use new GetFlags method instead.]
    DeprecatedGetFlags {
        responder: DirectoryDeprecatedGetFlagsResponder,
    },
    /// [DEPRECATED - Use new SetFlags method instead.]
    DeprecatedSetFlags {
        flags: OpenFlags,
        responder: DirectoryDeprecatedSetFlagsResponder,
    },
    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    GetFlags {
        responder: DirectoryGetFlagsResponder,
    },
    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    SetFlags {
        flags: Flags,
        responder: DirectorySetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: DirectoryQueryFilesystemResponder,
    },
    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetAttributes {
        query: NodeAttributesQuery,
        responder: DirectoryGetAttributesResponder,
    },
    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    UpdateAttributes {
        payload: MutableNodeAttributes,
        responder: DirectoryUpdateAttributesResponder,
    },
    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    Sync {
        responder: DirectorySyncResponder,
    },
    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    ListExtendedAttributes {
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetExtendedAttribute {
        name: Vec<u8>,
        responder: DirectoryGetExtendedAttributeResponder,
    },
    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    SetExtendedAttribute {
        name: Vec<u8>,
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
        responder: DirectorySetExtendedAttributeResponder,
    },
    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    RemoveExtendedAttribute {
        name: Vec<u8>,
        responder: DirectoryRemoveExtendedAttributeResponder,
    },
    /// DEPRECATED - Use `fuchsia.io/Directory.Open` instead.
    DeprecatedOpen {
        flags: OpenFlags,
        mode: ModeType,
        path: String,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// Open (or create) a node relative to this directory. Any errors are communicated via an
    /// epitaph sent on the `object` channel.
    ///
    /// Errors:
    /// * `ZX_ERR_BAD_PATH` if `path` is invalid
    /// * See [`Flags`] for other errors which may be communicated based on `flags`
    Open {
        path: String,
        flags: Flags,
        options: Options,
        object: fdomain_client::Channel,
        control_handle: DirectoryControlHandle,
    },
    /// Reads a collection of variably sized dirents into a buffer.
    /// The number of dirents in a directory may be very large: akin to
    /// calling read multiple times on a file, directories have a seek
    /// offset which is updated on subsequent calls to ReadDirents.
    /// Each call to ReadDirents will only return whole dirent structures,
    /// they will not get split across ReadDirent calls. When the seek
    /// offset reaches the end, `dirents` will be empty.
    ///
    /// These dirents are of the form:
    /// ```
    /// struct dirent {
    ///   // Describes the inode of the entry.
    ///   uint64 ino;
    ///   // Describes the length of the dirent name in bytes.
    ///   uint8 size;
    ///   // Describes the type of the entry. Aligned with the
    ///   // POSIX d_type values. Use `DirentType` constants.
    ///   uint8 type;
    ///   // Unterminated name of entry.
    ///   char name[0];
    /// }
    /// ```
    ///
    /// This method does not require any rights, since one could always probe for
    /// directory contents by triggering name conflicts during file creation.
    ReadDirents {
        max_bytes: u64,
        responder: DirectoryReadDirentsResponder,
    },
    /// Resets the directory seek offset.
    ///
    /// This method does not require any rights, similar to ReadDirents.
    Rewind {
        responder: DirectoryRewindResponder,
    },
    /// Acquires a token to a Directory which can be used to identify access to it at a later point
    /// in time. The token will remain valid for as long as the connection requesting the token
    /// remains open.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    GetToken {
        responder: DirectoryGetTokenResponder,
    },
    /// Creates a link to an object named src by the name dst, within a directory represented by
    /// token.
    ///
    /// `src` must be a resolved object name. Including "/" in the string will
    /// return `ZX_ERR_INVALID_ARGS`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will
    /// return `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and
    /// `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.
    ///
    /// This will be atomic with respect to renaming or unlinking the source concurrently e.g. if
    /// there are two actors operating concurrently, and one actor performs a rename that affects
    /// the source within this directory, and the other does a link, each will appear to occur
    /// atomically in an unspecified order.
    Link {
        src: String,
        dst_parent_token: fdomain_client::NullableHandle,
        dst: String,
        responder: DirectoryLinkResponder,
    },
    /// Removes a child node from the this directory's list of entries.
    ///
    /// Note: this does not guarantee that the underlying object is destroyed.
    /// Although the link will be removed from the containing directory,
    /// objects with multiple references (such as files which are still open)
    /// will not actually be destroyed until all references are closed.
    ///
    /// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
    ///   [`Rights.WRITE_BYTES`].
    /// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
    ///   support writing.
    /// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
    /// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
    /// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
    ///   containing a remote channel.
    /// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
    ///     something other than a directory was found.
    ///
    /// Other errors may be returned for filesystem-specific reasons.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.MODIFY_DIRECTORY`]
    Unlink {
        name: String,
        options: UnlinkOptions,
        responder: DirectoryUnlinkResponder,
    },
    /// Renames a node named `src` to the name `dst`, in a directory represented
    /// by `dst_parent_token`.
    ///
    /// `src` and `dst` must be valid node names.
    /// See [`Name`] for what constitutes a valid name.
    ///
    /// This method requires the following rights on both the current connection, and the connection
    /// identified by `dst_parent_token`:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.MODIFY_DIRECTORY`]
    ///
    /// The following requirements are necessary to avoid rights escalations.
    ///
    /// If the source and destination directory differ, the source directory must also have the
    /// maximal set of abilities supported for files, which would typically be
    /// [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and
    /// [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]
    /// right.
    ///
    /// If `src` refers to a directory, and differs from the destination directory, then the source
    /// directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.
    ///
    /// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
    /// * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.
    Rename {
        src: String,
        dst_parent_token: fdomain_client::Event,
        dst: String,
        responder: DirectoryRenameResponder,
    },
    /// Creates a symbolic link.
    ///
    /// `name` is the name to be given to the created symbolic link.
    /// `target` is the target of the symbolic link, which has no meaning on the server. The server
    /// will perform no validation of `target` except for a server chosen maximum length.
    /// `connection` is an optional server end of a channel that will speak the Symlink protocol
    /// on the successfully created node.
    ///
    /// * [`Rights.MODIFY_DIRECTORY`]
    ///
    /// * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.
    /// * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.
    /// * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].
    /// * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.
    CreateSymlink {
        name: String,
        target: Vec<u8>,
        connection: Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
        responder: DirectoryCreateSymlinkResponder,
    },
    /// Watches a directory, receiving events of added messages on the
    /// watcher request channel.
    ///
    /// Options must be zero; it is reserved.
    ///
    /// This method does not require any rights, similar to ReadDirents.
    Watch {
        mask: WatchMask,
        options: u32,
        watcher: fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
        responder: DirectoryWatchResponder,
    },
    /// 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: DirectoryControlHandle,
        method_type: fidl::MethodType,
    },
}

impl DirectoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_advisory_lock(
        self,
    ) -> Option<(AdvisoryLockRequest, DirectoryAdvisoryLockResponder)> {
        if let DirectoryRequest::AdvisoryLock { request, responder } = self {
            Some((request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        DirectoryControlHandle,
    )> {
        if let DirectoryRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(DirectoryQueryResponder)> {
        if let DirectoryRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_clone(
        self,
    ) -> Option<(OpenFlags, fdomain_client::fidl::ServerEnd<NodeMarker>, DirectoryControlHandle)>
    {
        if let DirectoryRequest::DeprecatedClone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_attr(self) -> Option<(DirectoryDeprecatedGetAttrResponder)> {
        if let DirectoryRequest::DeprecatedGetAttr { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, DirectoryDeprecatedSetAttrResponder)> {
        if let DirectoryRequest::DeprecatedSetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_flags(self) -> Option<(DirectoryDeprecatedGetFlagsResponder)> {
        if let DirectoryRequest::DeprecatedGetFlags { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_flags(
        self,
    ) -> Option<(OpenFlags, DirectoryDeprecatedSetFlagsResponder)> {
        if let DirectoryRequest::DeprecatedSetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_flags(self) -> Option<(DirectoryGetFlagsResponder)> {
        if let DirectoryRequest::GetFlags { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_flags(self) -> Option<(Flags, DirectorySetFlagsResponder)> {
        if let DirectoryRequest::SetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_filesystem(self) -> Option<(DirectoryQueryFilesystemResponder)> {
        if let DirectoryRequest::QueryFilesystem { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_attributes(
        self,
    ) -> Option<(NodeAttributesQuery, DirectoryGetAttributesResponder)> {
        if let DirectoryRequest::GetAttributes { query, responder } = self {
            Some((query, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_attributes(
        self,
    ) -> Option<(MutableNodeAttributes, DirectoryUpdateAttributesResponder)> {
        if let DirectoryRequest::UpdateAttributes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_extended_attributes(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        DirectoryControlHandle,
    )> {
        if let DirectoryRequest::ListExtendedAttributes { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, DirectoryGetExtendedAttributeResponder)> {
        if let DirectoryRequest::GetExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_extended_attribute(
        self,
    ) -> Option<(
        Vec<u8>,
        ExtendedAttributeValue,
        SetExtendedAttributeMode,
        DirectorySetExtendedAttributeResponder,
    )> {
        if let DirectoryRequest::SetExtendedAttribute { name, value, mode, responder } = self {
            Some((name, value, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, DirectoryRemoveExtendedAttributeResponder)> {
        if let DirectoryRequest::RemoveExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_open(
        self,
    ) -> Option<(
        OpenFlags,
        ModeType,
        String,
        fdomain_client::fidl::ServerEnd<NodeMarker>,
        DirectoryControlHandle,
    )> {
        if let DirectoryRequest::DeprecatedOpen { flags, mode, path, object, control_handle } = self
        {
            Some((flags, mode, path, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open(
        self,
    ) -> Option<(String, Flags, Options, fdomain_client::Channel, DirectoryControlHandle)> {
        if let DirectoryRequest::Open { path, flags, options, object, control_handle } = self {
            Some((path, flags, options, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_dirents(self) -> Option<(u64, DirectoryReadDirentsResponder)> {
        if let DirectoryRequest::ReadDirents { max_bytes, responder } = self {
            Some((max_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_rewind(self) -> Option<(DirectoryRewindResponder)> {
        if let DirectoryRequest::Rewind { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_token(self) -> Option<(DirectoryGetTokenResponder)> {
        if let DirectoryRequest::GetToken { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_link(
        self,
    ) -> Option<(String, fdomain_client::NullableHandle, String, DirectoryLinkResponder)> {
        if let DirectoryRequest::Link { src, dst_parent_token, dst, responder } = self {
            Some((src, dst_parent_token, dst, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unlink(self) -> Option<(String, UnlinkOptions, DirectoryUnlinkResponder)> {
        if let DirectoryRequest::Unlink { name, options, responder } = self {
            Some((name, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_rename(
        self,
    ) -> Option<(String, fdomain_client::Event, String, DirectoryRenameResponder)> {
        if let DirectoryRequest::Rename { src, dst_parent_token, dst, responder } = self {
            Some((src, dst_parent_token, dst, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_symlink(
        self,
    ) -> Option<(
        String,
        Vec<u8>,
        Option<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
        DirectoryCreateSymlinkResponder,
    )> {
        if let DirectoryRequest::CreateSymlink { name, target, connection, responder } = self {
            Some((name, target, connection, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(
        self,
    ) -> Option<(
        WatchMask,
        u32,
        fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
        DirectoryWatchResponder,
    )> {
        if let DirectoryRequest::Watch { mask, options, watcher, responder } = self {
            Some((mask, options, watcher, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DirectoryRequest::AdvisoryLock { .. } => "advisory_lock",
            DirectoryRequest::Clone { .. } => "clone",
            DirectoryRequest::Close { .. } => "close",
            DirectoryRequest::Query { .. } => "query",
            DirectoryRequest::DeprecatedClone { .. } => "deprecated_clone",
            DirectoryRequest::DeprecatedGetAttr { .. } => "deprecated_get_attr",
            DirectoryRequest::DeprecatedSetAttr { .. } => "deprecated_set_attr",
            DirectoryRequest::DeprecatedGetFlags { .. } => "deprecated_get_flags",
            DirectoryRequest::DeprecatedSetFlags { .. } => "deprecated_set_flags",
            DirectoryRequest::GetFlags { .. } => "get_flags",
            DirectoryRequest::SetFlags { .. } => "set_flags",
            DirectoryRequest::QueryFilesystem { .. } => "query_filesystem",
            DirectoryRequest::GetAttributes { .. } => "get_attributes",
            DirectoryRequest::UpdateAttributes { .. } => "update_attributes",
            DirectoryRequest::Sync { .. } => "sync",
            DirectoryRequest::ListExtendedAttributes { .. } => "list_extended_attributes",
            DirectoryRequest::GetExtendedAttribute { .. } => "get_extended_attribute",
            DirectoryRequest::SetExtendedAttribute { .. } => "set_extended_attribute",
            DirectoryRequest::RemoveExtendedAttribute { .. } => "remove_extended_attribute",
            DirectoryRequest::DeprecatedOpen { .. } => "deprecated_open",
            DirectoryRequest::Open { .. } => "open",
            DirectoryRequest::ReadDirents { .. } => "read_dirents",
            DirectoryRequest::Rewind { .. } => "rewind",
            DirectoryRequest::GetToken { .. } => "get_token",
            DirectoryRequest::Link { .. } => "link",
            DirectoryRequest::Unlink { .. } => "unlink",
            DirectoryRequest::Rename { .. } => "rename",
            DirectoryRequest::CreateSymlink { .. } => "create_symlink",
            DirectoryRequest::Watch { .. } => "watch",
            DirectoryRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            DirectoryRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for DirectoryControlHandle {
    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 DirectoryControlHandle {
    pub fn send_on_open_(
        &self,
        mut s: i32,
        mut info: Option<NodeInfoDeprecated>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<NodeOnOpenRequest>(
            (s, info.as_mut()),
            0,
            0x7fc7bbb1dbfd1972,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_representation(&self, mut payload: Representation) -> Result<(), fidl::Error> {
        self.inner.send::<Representation>(
            &mut payload,
            0,
            0x5cb40567d80a510c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fdomain_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut s: i32, mut attributes: &NodeAttributes) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut flags: OpenFlags) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<Flags, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|flags| (flags,))),
                self.tx_id,
                0x176eb318f64ec23,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut info: Option<&FilesystemInfo>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeQueryFilesystemResponse>(
            (s, info),
            self.tx_id,
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<ExtendedAttributeValue, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ExtendedAttributeValue, i32>>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut dirents: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DirectoryReadDirentsResponse>(
            (s, dirents),
            self.tx_id,
            0x3582806bf27faa0a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut s: i32,
        mut token: Option<fdomain_client::NullableHandle>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DirectoryGetTokenResponse>(
            (s, token),
            self.tx_id,
            0x26ae9d18763c8655,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for DirectoryWatcherMarker {
    type Proxy = DirectoryWatcherProxy;
    type RequestStream = DirectoryWatcherRequestStream;

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

pub trait DirectoryWatcherProxyInterface: Send + Sync {}

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

impl fdomain_client::fidl::Proxy for DirectoryWatcherProxy {
    type Protocol = DirectoryWatcherMarker;

    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 DirectoryWatcherProxy {
    /// Create a new Proxy for fuchsia.io/DirectoryWatcher.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <DirectoryWatcherMarker 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) -> DirectoryWatcherEventStream {
        DirectoryWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl DirectoryWatcherProxyInterface for DirectoryWatcherProxy {}

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

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

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

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

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

impl DirectoryWatcherEvent {
    /// Decodes a message buffer as a [`DirectoryWatcherEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DirectoryWatcherEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <DirectoryWatcherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for DirectoryWatcherRequestStream {
    type Protocol = DirectoryWatcherMarker;
    type ControlHandle = DirectoryWatcherControlHandle;

    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 {
        DirectoryWatcherControlHandle { 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 DirectoryWatcherRequestStream {
    type Item = Result<DirectoryWatcherRequest, 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 DirectoryWatcherRequestStream 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 {
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <DirectoryWatcherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// DirectoryWatcher transmits messages from a filesystem server
/// about events happening in the filesystem. Clients can register
/// new watchers using the `Directory.Watch` method, where they can
/// filter which events they want to receive notifications for.
///
/// The DirectoryWatcher will send messages of the form:
/// ```
/// struct {
///   uint8 event;
///   uint8 len;
///   char name[];
/// };
/// ```
/// Where names are NOT null-terminated. The name is the relative
/// path to the entry the event is refering to. It will be empty if
/// the event isn't referencing a particular entry (e.g. for the
/// `IDLE` event).
#[derive(Debug)]
pub enum DirectoryWatcherRequest {}

impl DirectoryWatcherRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

impl fdomain_client::fidl::ControlHandle for DirectoryWatcherControlHandle {
    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 DirectoryWatcherControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for ExtendedAttributeIteratorMarker {
    type Proxy = ExtendedAttributeIteratorProxy;
    type RequestStream = ExtendedAttributeIteratorRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) ExtendedAttributeIterator";
}
pub type ExtendedAttributeIteratorGetNextResult = Result<(Vec<Vec<u8>>, bool), i32>;

pub trait ExtendedAttributeIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<ExtendedAttributeIteratorGetNextResult, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ExtendedAttributeIteratorProxy {
    type Protocol = ExtendedAttributeIteratorMarker;

    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 ExtendedAttributeIteratorProxy {
    /// Create a new Proxy for fuchsia.io/ExtendedAttributeIterator.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <ExtendedAttributeIteratorMarker 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) -> ExtendedAttributeIteratorEventStream {
        ExtendedAttributeIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get the next chunk of extended attribute names. If this is the last
    /// chunk, last will be true, and the channel will be closed after the
    /// call.
    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ExtendedAttributeIteratorGetNextResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ExtendedAttributeIteratorProxyInterface::r#get_next(self)
    }
}

impl ExtendedAttributeIteratorProxyInterface for ExtendedAttributeIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        ExtendedAttributeIteratorGetNextResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ExtendedAttributeIteratorGetNextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeIteratorGetNextResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3ba664a1c2e45a7,
            >(_buf?)?;
            Ok(_response.map(|x| (x.attributes, x.last)))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ExtendedAttributeIteratorGetNextResult,
        >(
            (),
            0x3ba664a1c2e45a7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl ExtendedAttributeIteratorEvent {
    /// Decodes a message buffer as a [`ExtendedAttributeIteratorEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ExtendedAttributeIteratorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ExtendedAttributeIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            })
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for ExtendedAttributeIteratorRequestStream {
    type Protocol = ExtendedAttributeIteratorMarker;
    type ControlHandle = ExtendedAttributeIteratorControlHandle;

    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 {
        ExtendedAttributeIteratorControlHandle { 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 ExtendedAttributeIteratorRequestStream {
    type Item = Result<ExtendedAttributeIteratorRequest, 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 ExtendedAttributeIteratorRequestStream 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 {
                0x3ba664a1c2e45a7 => {
                    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 = ExtendedAttributeIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ExtendedAttributeIteratorRequest::GetNext {
                        responder: ExtendedAttributeIteratorGetNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ExtendedAttributeIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ExtendedAttributeIteratorRequest {
    /// Get the next chunk of extended attribute names. If this is the last
    /// chunk, last will be true, and the channel will be closed after the
    /// call.
    GetNext { responder: ExtendedAttributeIteratorGetNextResponder },
}

impl ExtendedAttributeIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(ExtendedAttributeIteratorGetNextResponder)> {
        if let ExtendedAttributeIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for ExtendedAttributeIteratorControlHandle {
    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 ExtendedAttributeIteratorControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<(&[Vec<u8>], bool), i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ExtendedAttributeIteratorGetNextResponse,
            i32,
        >>(
            result,
            self.tx_id,
            0x3ba664a1c2e45a7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for FileMarker {
    type Proxy = FileProxy;
    type RequestStream = FileRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.io.File";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for FileMarker {}
pub type FileSeekResult = Result<u64, i32>;
pub type FileReadAtResult = Result<Vec<u8>, i32>;
pub type FileWriteAtResult = Result<u64, i32>;
pub type FileResizeResult = Result<(), i32>;
pub type FileGetBackingMemoryResult = Result<fdomain_client::Vmo, i32>;
pub type FileAllocateResult = Result<(), i32>;
pub type FileEnableVerityResult = Result<(), i32>;

pub trait FileProxyInterface: Send + Sync {
    type AdvisoryLockResponseFut: std::future::Future<Output = Result<AdvisoryLockingAdvisoryLockResult, fidl::Error>>
        + Send;
    fn r#advisory_lock(&self, request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut;
    type LinkIntoResponseFut: std::future::Future<Output = Result<LinkableLinkIntoResult, fidl::Error>>
        + Send;
    fn r#link_into(
        &self,
        dst_parent_token: fdomain_client::Event,
        dst: &str,
    ) -> Self::LinkIntoResponseFut;
    fn r#clone(
        &self,
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    fn r#deprecated_clone(
        &self,
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type DeprecatedGetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut;
    type DeprecatedSetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#deprecated_set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut;
    type DeprecatedGetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut;
    type DeprecatedSetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#deprecated_set_flags(&self, flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<NodeGetFlagsResult, fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<NodeSetFlagsResult, fidl::Error>>
        + Send;
    fn r#set_flags(&self, flags: Flags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetAttributesResponseFut: std::future::Future<Output = Result<NodeGetAttributesResult, fidl::Error>>
        + Send;
    fn r#get_attributes(&self, query: NodeAttributesQuery) -> Self::GetAttributesResponseFut;
    type UpdateAttributesResponseFut: std::future::Future<Output = Result<NodeUpdateAttributesResult, fidl::Error>>
        + Send;
    fn r#update_attributes(
        &self,
        payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut;
    type SyncResponseFut: std::future::Future<Output = Result<NodeSyncResult, fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#list_extended_attributes(
        &self,
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type GetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeGetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#get_extended_attribute(&self, name: &[u8]) -> Self::GetExtendedAttributeResponseFut;
    type SetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeSetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#set_extended_attribute(
        &self,
        name: &[u8],
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut;
    type RemoveExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeRemoveExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#remove_extended_attribute(&self, name: &[u8]) -> Self::RemoveExtendedAttributeResponseFut;
    type ReadResponseFut: std::future::Future<Output = Result<ReadableReadResult, fidl::Error>>
        + Send;
    fn r#read(&self, count: u64) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<WritableWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, data: &[u8]) -> Self::WriteResponseFut;
    type DescribeResponseFut: std::future::Future<Output = Result<FileInfo, fidl::Error>> + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
    type SeekResponseFut: std::future::Future<Output = Result<FileSeekResult, fidl::Error>> + Send;
    fn r#seek(&self, origin: SeekOrigin, offset: i64) -> Self::SeekResponseFut;
    type ReadAtResponseFut: std::future::Future<Output = Result<FileReadAtResult, fidl::Error>>
        + Send;
    fn r#read_at(&self, count: u64, offset: u64) -> Self::ReadAtResponseFut;
    type WriteAtResponseFut: std::future::Future<Output = Result<FileWriteAtResult, fidl::Error>>
        + Send;
    fn r#write_at(&self, data: &[u8], offset: u64) -> Self::WriteAtResponseFut;
    type ResizeResponseFut: std::future::Future<Output = Result<FileResizeResult, fidl::Error>>
        + Send;
    fn r#resize(&self, length: u64) -> Self::ResizeResponseFut;
    type GetBackingMemoryResponseFut: std::future::Future<Output = Result<FileGetBackingMemoryResult, fidl::Error>>
        + Send;
    fn r#get_backing_memory(&self, flags: VmoFlags) -> Self::GetBackingMemoryResponseFut;
    type AllocateResponseFut: std::future::Future<Output = Result<FileAllocateResult, fidl::Error>>
        + Send;
    fn r#allocate(&self, offset: u64, length: u64, mode: AllocateMode)
    -> Self::AllocateResponseFut;
    type EnableVerityResponseFut: std::future::Future<Output = Result<FileEnableVerityResult, fidl::Error>>
        + Send;
    fn r#enable_verity(&self, options: &VerificationOptions) -> Self::EnableVerityResponseFut;
}

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

impl fdomain_client::fidl::Proxy for FileProxy {
    type Protocol = FileMarker;

    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 FileProxy {
    /// Create a new Proxy for fuchsia.io/File.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <FileMarker 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) -> FileEventStream {
        FileEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    pub fn r#advisory_lock(
        &self,
        mut request: &AdvisoryLockRequest,
    ) -> fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#advisory_lock(self, request)
    }

    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    pub fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#link_into(self, dst_parent_token, dst)
    }

    pub fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        FileProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect> {
        FileProxyInterface::r#query(self)
    }

    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    pub fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        FileProxyInterface::r#deprecated_clone(self, flags, object)
    }

    /// DEPRECATED - Use `Node.GetAttributes` instead.
    pub fn r#deprecated_get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#deprecated_get_attr(self)
    }

    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    pub fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        FileProxyInterface::r#deprecated_set_attr(self, flags, attributes)
    }

    /// [DEPRECATED - Use new GetFlags method instead.]
    pub fn r#deprecated_get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#deprecated_get_flags(self)
    }

    /// [DEPRECATED - Use new SetFlags method instead.]
    pub fn r#deprecated_set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        FileProxyInterface::r#deprecated_set_flags(self, flags)
    }

    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#get_flags(self)
    }

    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    pub fn r#set_flags(
        &self,
        mut flags: Flags,
    ) -> fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#set_flags(self, flags)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_attributes(
        &self,
        mut query: NodeAttributesQuery,
    ) -> fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#get_attributes(self, query)
    }

    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#update_attributes(self, payload)
    }

    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<NodeSyncResult, fdomain_client::fidl::FDomainResourceDialect>
    {
        FileProxyInterface::r#sync(self)
    }

    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        FileProxyInterface::r#list_extended_attributes(self, iterator)
    }

    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#get_extended_attribute(self, name)
    }

    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#set_extended_attribute(self, name, value, mode)
    }

    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#remove_extended_attribute(self, name)
    }

    /// Reads up to 'count' bytes at the seek offset.
    /// The seek offset is moved forward by the number of bytes read.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that the seek offset
    ///   has reached the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that the
    ///   seek offset is already at or beyond the end of file, and no data could
    ///   be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually read anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    pub fn r#read(
        &self,
        mut count: u64,
    ) -> fidl::client::QueryResponseFut<
        ReadableReadResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#read(self, count)
    }

    /// Writes data at the seek offset.
    /// The seek offset is moved forward by the number of bytes written.
    /// If the file is in append mode, the seek offset is first set to the end
    /// of the file, followed by the write, in one atomic step.
    ///
    /// The file size may grow if the seek offset plus `data.length` is beyond
    /// the current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file and return a
    ///   successful write of zero bytes.  The seek offset is still updated if
    ///   in append mode.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    pub fn r#write(
        &self,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        WritableWriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#write(self, data)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<FileInfo, fdomain_client::fidl::FDomainResourceDialect>
    {
        FileProxyInterface::r#describe(self)
    }

    /// Moves the offset at which the next invocation of [`Read`] or [`Write`]
    /// will occur. The seek offset is specific to each file connection.
    ///
    /// + request `origin` the reference point where `offset` will be based on.
    /// + request `offset` the number of bytes to seek.
    /// - response `offset_from_start` the adjusted seek offset, from the start
    ///   of the file.
    ///
    /// This method does not require any rights.
    pub fn r#seek(
        &self,
        mut origin: SeekOrigin,
        mut offset: i64,
    ) -> fidl::client::QueryResponseFut<FileSeekResult, fdomain_client::fidl::FDomainResourceDialect>
    {
        FileProxyInterface::r#seek(self, origin, offset)
    }

    /// Reads up to 'count' bytes at the provided offset.
    /// Does not affect the seek offset.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that `ReadAt` has hit
    ///   the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that `offset`
    ///   is at or past the end of file, and no data can be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually reading anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    pub fn r#read_at(
        &self,
        mut count: u64,
        mut offset: u64,
    ) -> fidl::client::QueryResponseFut<
        FileReadAtResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#read_at(self, count, offset)
    }

    /// Writes data at the provided offset.
    /// Does not affect the seek offset.
    ///
    /// The file size may grow if `offset` plus `data.length` is past the
    /// current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// + request `offset` the offset from start of the file to begin writing.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file, and will return a
    ///   successful write of zero bytes.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    pub fn r#write_at(
        &self,
        mut data: &[u8],
        mut offset: u64,
    ) -> fidl::client::QueryResponseFut<
        FileWriteAtResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#write_at(self, data, offset)
    }

    /// Shrinks or grows the file size to 'length' bytes.
    ///
    /// If file size is reduced by this operation, the extra trailing data'
    /// is discarded.
    /// If file size is increased by this operation, the extended area appears
    /// as if it was zeroed.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    pub fn r#resize(
        &self,
        mut length: u64,
    ) -> fidl::client::QueryResponseFut<
        FileResizeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#resize(self, length)
    }

    /// Acquires a [`zx.Handle:VMO`] representing this file, if there is one,
    /// with the requested access rights.
    ///
    /// Implementations are not required to implement files backed by VMOs so
    /// this request may fail. Additionally, implementations may only support
    /// a certain subset of the flags. Clients should be prepared with fallback
    /// behavior if this request fails.
    ///
    /// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
    /// implementation is free to choose the semantics of the returned VMO.
    ///
    /// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
    /// - response `vmo` the requested [`zx.Handle:VMO`].
    /// * error a [`zx.Status`] value indicating the failure.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
    /// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
    /// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
    pub fn r#get_backing_memory(
        &self,
        mut flags: VmoFlags,
    ) -> fidl::client::QueryResponseFut<
        FileGetBackingMemoryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#get_backing_memory(self, flags)
    }

    /// Pre-allocate on-disk space for this file.
    pub fn r#allocate(
        &self,
        mut offset: u64,
        mut length: u64,
        mut mode: AllocateMode,
    ) -> fidl::client::QueryResponseFut<
        FileAllocateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#allocate(self, offset, length, mode)
    }

    /// Enables verification for the file (permanently) which involves computing a merkle tree for
    /// the file. Forces a flush prior to building the merkle tree to ensure cached data is
    /// captured. Future reads will be verified against the computed merkle tree and writes will be
    /// rejected. This method can take some time to complete as it depends on the size of the file.
    /// This method can be aborted by closing the connection that this method was issued on.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.
    /// Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.
    /// Also returns any error that might arise from reading the file, or from flushing the file,
    /// such as `ZX_ERR_IO`.
    pub fn r#enable_verity(
        &self,
        mut options: &VerificationOptions,
    ) -> fidl::client::QueryResponseFut<
        FileEnableVerityResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        FileProxyInterface::r#enable_verity(self, options)
    }
}

impl FileProxyInterface for FileProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6ee9c0ad53ec87aa,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AdvisoryLockingAdvisoryLockRequest,
            AdvisoryLockingAdvisoryLockResult,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type LinkIntoResponseFut = fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LinkableLinkIntoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x54f3949246a03e74,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<LinkableLinkIntoRequest, LinkableLinkIntoResult>(
            (dst_parent_token, dst),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fdomain_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fdomain_fuchsia_unknown::QueryableQueryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeDeprecatedCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type DeprecatedGetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x78985e216314dafd,
            >(_buf?)?;
            Ok((_response.s, _response.attributes))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, NodeAttributes)>(
            (),
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedGetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b88fffb8eda3aa1,
            >(_buf?)?;
            Ok((_response.s, _response.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, OpenFlags)>(
            (),
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_flags(&self, mut flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x176eb318f64ec23,
            >(_buf?)?
            .into_result_fdomain::<FileMarker>("get_flags")?;
            Ok(_response.map(|x| x.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetFlagsResult>(
            (),
            0x176eb318f64ec23,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_flags(&self, mut flags: Flags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x55a8028685791ea8,
            >(_buf?)?
            .into_result_fdomain::<FileMarker>("set_flags")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, NodeSetFlagsResult>(
            (flags,),
            0x55a8028685791ea8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6f344a1c6b0a0610,
            >(_buf?)?;
            Ok((_response.s, _response.info))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<FilesystemInfo>>),
        >(
            (),
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3d4396a638ea053b,
            >(_buf?)?;
            Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
        }
        self.client.send_query_and_decode::<NodeGetAttributesRequest, NodeGetAttributesResult>(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3308c1da5a89bf08,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MutableNodeAttributes, NodeUpdateAttributesResult>(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SyncResponseFut = fidl::client::QueryResponseFut<
        NodeSyncResult,
        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<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c5c27ca0ab5dc49,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeSyncResult>(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x45ffa3ccfdeb76db,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeGetExtendedAttributeRequest,
            NodeGetExtendedAttributeResult,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4a951362f681f23c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeSetExtendedAttributeRequest,
            NodeSetExtendedAttributeResult,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7a0b9f3a9bf9032d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeRemoveExtendedAttributeRequest,
            NodeRemoveExtendedAttributeResult,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadResponseFut = fidl::client::QueryResponseFut<
        ReadableReadResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#read(&self, mut count: u64) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReadableReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReadableReadResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x57e419a298c8ede,
            >(_buf?)?;
            Ok(_response.map(|x| x.data))
        }
        self.client.send_query_and_decode::<ReadableReadRequest, ReadableReadResult>(
            (count,),
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteResponseFut = fidl::client::QueryResponseFut<
        WritableWriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WritableWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WritableWriteResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6a31437832469f82,
            >(_buf?)?;
            Ok(_response.map(|x| x.actual_count))
        }
        self.client.send_query_and_decode::<WritableWriteRequest, WritableWriteResult>(
            (data,),
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type SeekResponseFut = fidl::client::QueryResponseFut<
        FileSeekResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#seek(&self, mut origin: SeekOrigin, mut offset: i64) -> Self::SeekResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileSeekResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileSeekResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x78079168162c5207,
            >(_buf?)?;
            Ok(_response.map(|x| x.offset_from_start))
        }
        self.client.send_query_and_decode::<FileSeekRequest, FileSeekResult>(
            (origin, offset),
            0x78079168162c5207,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadAtResponseFut = fidl::client::QueryResponseFut<
        FileReadAtResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#read_at(&self, mut count: u64, mut offset: u64) -> Self::ReadAtResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileReadAtResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileReadAtResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1607a293a60d723e,
            >(_buf?)?;
            Ok(_response.map(|x| x.data))
        }
        self.client.send_query_and_decode::<FileReadAtRequest, FileReadAtResult>(
            (count, offset),
            0x1607a293a60d723e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteAtResponseFut = fidl::client::QueryResponseFut<
        FileWriteAtResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#write_at(&self, mut data: &[u8], mut offset: u64) -> Self::WriteAtResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileWriteAtResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileWriteAtResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x793eefc0045e792b,
            >(_buf?)?;
            Ok(_response.map(|x| x.actual_count))
        }
        self.client.send_query_and_decode::<FileWriteAtRequest, FileWriteAtResult>(
            (data, offset),
            0x793eefc0045e792b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ResizeResponseFut = fidl::client::QueryResponseFut<
        FileResizeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#resize(&self, mut length: u64) -> Self::ResizeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileResizeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2b80825f0535743a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FileResizeRequest, FileResizeResult>(
            (length,),
            0x2b80825f0535743a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBackingMemoryResponseFut = fidl::client::QueryResponseFut<
        FileGetBackingMemoryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_backing_memory(&self, mut flags: VmoFlags) -> Self::GetBackingMemoryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileGetBackingMemoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileGetBackingMemoryResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xa6a9e654cbf62b,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client
            .send_query_and_decode::<FileGetBackingMemoryRequest, FileGetBackingMemoryResult>(
                (flags,),
                0xa6a9e654cbf62b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AllocateResponseFut = fidl::client::QueryResponseFut<
        FileAllocateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#allocate(
        &self,
        mut offset: u64,
        mut length: u64,
        mut mode: AllocateMode,
    ) -> Self::AllocateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileAllocateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x77fa0c330b57fd2e,
            >(_buf?)?
            .into_result_fdomain::<FileMarker>("allocate")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FileAllocateRequest, FileAllocateResult>(
            (offset, length, mode),
            0x77fa0c330b57fd2e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type EnableVerityResponseFut = fidl::client::QueryResponseFut<
        FileEnableVerityResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#enable_verity(&self, mut options: &VerificationOptions) -> Self::EnableVerityResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileEnableVerityResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c421ec3faaeb8bb,
            >(_buf?)?
            .into_result_fdomain::<FileMarker>("enable_verity")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FileEnableVerityRequest, FileEnableVerityResult>(
            (options,),
            0x2c421ec3faaeb8bb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum FileEvent {
    OnOpen_ {
        s: i32,
        info: Option<Box<NodeInfoDeprecated>>,
    },
    OnRepresentation {
        payload: Representation,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl FileEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_open_(self) -> Option<(i32, Option<Box<NodeInfoDeprecated>>)> {
        if let FileEvent::OnOpen_ { s, info } = self { Some((s, info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_representation(self) -> Option<Representation> {
        if let FileEvent::OnRepresentation { payload } = self { Some((payload)) } else { None }
    }

    /// Decodes a message buffer as a [`FileEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FileEvent, 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 {
            0x7fc7bbb1dbfd1972 => {
                let mut out = fidl::new_empty!(
                    NodeOnOpenRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeOnOpenRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FileEvent::OnOpen_ { s: out.s, info: out.info }))
            }
            0x5cb40567d80a510c => {
                let mut out =
                    fidl::new_empty!(Representation, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<Representation>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FileEvent::OnRepresentation { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(FileEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FileMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for FileRequestStream {
    type Protocol = FileMarker;
    type ControlHandle = FileControlHandle;

    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 {
        FileControlHandle { 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 FileRequestStream {
    type Item = Result<FileRequest, 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 FileRequestStream 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 {
                    0x6ee9c0ad53ec87aa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AdvisoryLockingAdvisoryLockRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<AdvisoryLockingAdvisoryLockRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::AdvisoryLock {
                            request: req.request,

                            responder: FileAdvisoryLockResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54f3949246a03e74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinkableLinkIntoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LinkableLinkIntoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::LinkInto {
                            dst_parent_token: req.dst_parent_token,
                            dst: req.dst,

                            responder: FileLinkIntoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fdomain_fuchsia_unknown::CloneableCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Close {
                            responder: FileCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Query {
                            responder: FileQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a61678f293ce16f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::DeprecatedClone {
                            flags: req.flags,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x78985e216314dafd => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::DeprecatedGetAttr {
                            responder: FileDeprecatedGetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4186c0f40d938f46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetAttrRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::DeprecatedSetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: FileDeprecatedSetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b88fffb8eda3aa1 => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::DeprecatedGetFlags {
                            responder: FileDeprecatedGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::DeprecatedSetFlags {
                            flags: req.flags,

                            responder: FileDeprecatedSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x176eb318f64ec23 => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetFlags {
                            responder: FileGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55a8028685791ea8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::SetFlags {
                            flags: req.flags,

                            responder: FileSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f344a1c6b0a0610 => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::QueryFilesystem {
                            responder: FileQueryFilesystemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d4396a638ea053b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetAttributes {
                            query: req.query,

                            responder: FileGetAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3308c1da5a89bf08 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MutableNodeAttributes,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MutableNodeAttributes>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::UpdateAttributes {
                            payload: req,
                            responder: FileUpdateAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c5c27ca0ab5dc49 => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Sync {
                            responder: FileSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4b61033de007fcd0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeListExtendedAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeListExtendedAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::ListExtendedAttributes {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x45ffa3ccfdeb76db => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetExtendedAttribute {
                            name: req.name,

                            responder: FileGetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a951362f681f23c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::SetExtendedAttribute {
                            name: req.name,
                            value: req.value,
                            mode: req.mode,

                            responder: FileSetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a0b9f3a9bf9032d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeRemoveExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeRemoveExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::RemoveExtendedAttribute {
                            name: req.name,

                            responder: FileRemoveExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57e419a298c8ede => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ReadableReadRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ReadableReadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Read {
                            count: req.count,

                            responder: FileReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6a31437832469f82 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WritableWriteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<WritableWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Write {
                            data: req.data,

                            responder: FileWriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68b5ac00c62906bc => {
                        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 = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Describe {
                            responder: FileDescribeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78079168162c5207 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileSeekRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileSeekRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Seek {
                            origin: req.origin,
                            offset: req.offset,

                            responder: FileSeekResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1607a293a60d723e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileReadAtRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileReadAtRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::ReadAt {
                            count: req.count,
                            offset: req.offset,

                            responder: FileReadAtResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x793eefc0045e792b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileWriteAtRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileWriteAtRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::WriteAt {
                            data: req.data,
                            offset: req.offset,

                            responder: FileWriteAtResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2b80825f0535743a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileResizeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileResizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Resize {
                            length: req.length,

                            responder: FileResizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa6a9e654cbf62b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileGetBackingMemoryRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileGetBackingMemoryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetBackingMemory {
                            flags: req.flags,

                            responder: FileGetBackingMemoryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x77fa0c330b57fd2e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileAllocateRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileAllocateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Allocate {
                            offset: req.offset,
                            length: req.length,
                            mode: req.mode,

                            responder: FileAllocateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c421ec3faaeb8bb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FileEnableVerityRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<FileEnableVerityRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::EnableVerity {
                            options: req.options,

                            responder: FileEnableVerityResponder {
                                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(FileRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: FileControlHandle { 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(FileRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: FileControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FileMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A [`Node`] which contains a sequence of bytes of definite length.
///
/// NOTE: cloned connections do not share their seek offset with their source
/// connection.
#[derive(Debug)]
pub enum FileRequest {
    /// Acquires an advisory lock on the underlying file.
    ///
    /// The lock lasts until either this connection is closed or
    /// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
    /// explicitly.
    ///
    /// Advisory locks are purely advisory. They do not prevent actual read or
    /// write operations from occurring on the file, either through this
    /// connection or through other connections.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
    /// * [`Rights.WRITE_BYTES`] if `request.type` is
    ///   [`AdvisoryLockType.WRITE`].
    ///
    /// # Errors
    ///
    /// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
    ///   example, another connection might hold a conflicting lock type.
    /// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
    /// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
    ///   to acquire the given type of lock.
    AdvisoryLock {
        request: AdvisoryLockRequest,
        responder: FileAdvisoryLockResponder,
    },
    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    LinkInto {
        dst_parent_token: fdomain_client::Event,
        dst: String,
        responder: FileLinkIntoResponder,
    },
    Clone {
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        control_handle: FileControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: FileCloseResponder,
    },
    Query {
        responder: FileQueryResponder,
    },
    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    DeprecatedClone {
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
        control_handle: FileControlHandle,
    },
    /// DEPRECATED - Use `Node.GetAttributes` instead.
    DeprecatedGetAttr {
        responder: FileDeprecatedGetAttrResponder,
    },
    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    DeprecatedSetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: FileDeprecatedSetAttrResponder,
    },
    /// [DEPRECATED - Use new GetFlags method instead.]
    DeprecatedGetFlags {
        responder: FileDeprecatedGetFlagsResponder,
    },
    /// [DEPRECATED - Use new SetFlags method instead.]
    DeprecatedSetFlags {
        flags: OpenFlags,
        responder: FileDeprecatedSetFlagsResponder,
    },
    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    GetFlags {
        responder: FileGetFlagsResponder,
    },
    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    SetFlags {
        flags: Flags,
        responder: FileSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: FileQueryFilesystemResponder,
    },
    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetAttributes {
        query: NodeAttributesQuery,
        responder: FileGetAttributesResponder,
    },
    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    UpdateAttributes {
        payload: MutableNodeAttributes,
        responder: FileUpdateAttributesResponder,
    },
    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    Sync {
        responder: FileSyncResponder,
    },
    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    ListExtendedAttributes {
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        control_handle: FileControlHandle,
    },
    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetExtendedAttribute {
        name: Vec<u8>,
        responder: FileGetExtendedAttributeResponder,
    },
    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    SetExtendedAttribute {
        name: Vec<u8>,
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
        responder: FileSetExtendedAttributeResponder,
    },
    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    RemoveExtendedAttribute {
        name: Vec<u8>,
        responder: FileRemoveExtendedAttributeResponder,
    },
    /// Reads up to 'count' bytes at the seek offset.
    /// The seek offset is moved forward by the number of bytes read.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that the seek offset
    ///   has reached the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that the
    ///   seek offset is already at or beyond the end of file, and no data could
    ///   be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually read anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    Read {
        count: u64,
        responder: FileReadResponder,
    },
    /// Writes data at the seek offset.
    /// The seek offset is moved forward by the number of bytes written.
    /// If the file is in append mode, the seek offset is first set to the end
    /// of the file, followed by the write, in one atomic step.
    ///
    /// The file size may grow if the seek offset plus `data.length` is beyond
    /// the current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file and return a
    ///   successful write of zero bytes.  The seek offset is still updated if
    ///   in append mode.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    Write {
        data: Vec<u8>,
        responder: FileWriteResponder,
    },
    Describe {
        responder: FileDescribeResponder,
    },
    /// Moves the offset at which the next invocation of [`Read`] or [`Write`]
    /// will occur. The seek offset is specific to each file connection.
    ///
    /// + request `origin` the reference point where `offset` will be based on.
    /// + request `offset` the number of bytes to seek.
    /// - response `offset_from_start` the adjusted seek offset, from the start
    ///   of the file.
    ///
    /// This method does not require any rights.
    Seek {
        origin: SeekOrigin,
        offset: i64,
        responder: FileSeekResponder,
    },
    /// Reads up to 'count' bytes at the provided offset.
    /// Does not affect the seek offset.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that `ReadAt` has hit
    ///   the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that `offset`
    ///   is at or past the end of file, and no data can be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually reading anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    ReadAt {
        count: u64,
        offset: u64,
        responder: FileReadAtResponder,
    },
    /// Writes data at the provided offset.
    /// Does not affect the seek offset.
    ///
    /// The file size may grow if `offset` plus `data.length` is past the
    /// current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// + request `offset` the offset from start of the file to begin writing.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file, and will return a
    ///   successful write of zero bytes.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    WriteAt {
        data: Vec<u8>,
        offset: u64,
        responder: FileWriteAtResponder,
    },
    /// Shrinks or grows the file size to 'length' bytes.
    ///
    /// If file size is reduced by this operation, the extra trailing data'
    /// is discarded.
    /// If file size is increased by this operation, the extended area appears
    /// as if it was zeroed.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    Resize {
        length: u64,
        responder: FileResizeResponder,
    },
    /// Acquires a [`zx.Handle:VMO`] representing this file, if there is one,
    /// with the requested access rights.
    ///
    /// Implementations are not required to implement files backed by VMOs so
    /// this request may fail. Additionally, implementations may only support
    /// a certain subset of the flags. Clients should be prepared with fallback
    /// behavior if this request fails.
    ///
    /// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
    /// implementation is free to choose the semantics of the returned VMO.
    ///
    /// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
    /// - response `vmo` the requested [`zx.Handle:VMO`].
    /// * error a [`zx.Status`] value indicating the failure.
    ///
    /// This method requires the following rights:
    ///
    /// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
    /// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
    /// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
    GetBackingMemory {
        flags: VmoFlags,
        responder: FileGetBackingMemoryResponder,
    },
    /// Pre-allocate on-disk space for this file.
    Allocate {
        offset: u64,
        length: u64,
        mode: AllocateMode,
        responder: FileAllocateResponder,
    },
    /// Enables verification for the file (permanently) which involves computing a merkle tree for
    /// the file. Forces a flush prior to building the merkle tree to ensure cached data is
    /// captured. Future reads will be verified against the computed merkle tree and writes will be
    /// rejected. This method can take some time to complete as it depends on the size of the file.
    /// This method can be aborted by closing the connection that this method was issued on.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.
    /// Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.
    /// Also returns any error that might arise from reading the file, or from flushing the file,
    /// such as `ZX_ERR_IO`.
    EnableVerity {
        options: VerificationOptions,
        responder: FileEnableVerityResponder,
    },
    /// 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: FileControlHandle,
        method_type: fidl::MethodType,
    },
}

impl FileRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_advisory_lock(self) -> Option<(AdvisoryLockRequest, FileAdvisoryLockResponder)> {
        if let FileRequest::AdvisoryLock { request, responder } = self {
            Some((request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_link_into(self) -> Option<(fdomain_client::Event, String, FileLinkIntoResponder)> {
        if let FileRequest::LinkInto { dst_parent_token, dst, responder } = self {
            Some((dst_parent_token, dst, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        FileControlHandle,
    )> {
        if let FileRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(FileQueryResponder)> {
        if let FileRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_clone(
        self,
    ) -> Option<(OpenFlags, fdomain_client::fidl::ServerEnd<NodeMarker>, FileControlHandle)> {
        if let FileRequest::DeprecatedClone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_attr(self) -> Option<(FileDeprecatedGetAttrResponder)> {
        if let FileRequest::DeprecatedGetAttr { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, FileDeprecatedSetAttrResponder)> {
        if let FileRequest::DeprecatedSetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_flags(self) -> Option<(FileDeprecatedGetFlagsResponder)> {
        if let FileRequest::DeprecatedGetFlags { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_flags(self) -> Option<(OpenFlags, FileDeprecatedSetFlagsResponder)> {
        if let FileRequest::DeprecatedSetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_flags(self) -> Option<(FileGetFlagsResponder)> {
        if let FileRequest::GetFlags { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_flags(self) -> Option<(Flags, FileSetFlagsResponder)> {
        if let FileRequest::SetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_filesystem(self) -> Option<(FileQueryFilesystemResponder)> {
        if let FileRequest::QueryFilesystem { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_attributes(self) -> Option<(NodeAttributesQuery, FileGetAttributesResponder)> {
        if let FileRequest::GetAttributes { query, responder } = self {
            Some((query, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_attributes(
        self,
    ) -> Option<(MutableNodeAttributes, FileUpdateAttributesResponder)> {
        if let FileRequest::UpdateAttributes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_extended_attributes(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>, FileControlHandle)>
    {
        if let FileRequest::ListExtendedAttributes { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, FileGetExtendedAttributeResponder)> {
        if let FileRequest::GetExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_extended_attribute(
        self,
    ) -> Option<(
        Vec<u8>,
        ExtendedAttributeValue,
        SetExtendedAttributeMode,
        FileSetExtendedAttributeResponder,
    )> {
        if let FileRequest::SetExtendedAttribute { name, value, mode, responder } = self {
            Some((name, value, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, FileRemoveExtendedAttributeResponder)> {
        if let FileRequest::RemoveExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read(self) -> Option<(u64, FileReadResponder)> {
        if let FileRequest::Read { count, responder } = self {
            Some((count, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(Vec<u8>, FileWriteResponder)> {
        if let FileRequest::Write { data, responder } = self {
            Some((data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(FileDescribeResponder)> {
        if let FileRequest::Describe { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_seek(self) -> Option<(SeekOrigin, i64, FileSeekResponder)> {
        if let FileRequest::Seek { origin, offset, responder } = self {
            Some((origin, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_at(self) -> Option<(u64, u64, FileReadAtResponder)> {
        if let FileRequest::ReadAt { count, offset, responder } = self {
            Some((count, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_at(self) -> Option<(Vec<u8>, u64, FileWriteAtResponder)> {
        if let FileRequest::WriteAt { data, offset, responder } = self {
            Some((data, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_resize(self) -> Option<(u64, FileResizeResponder)> {
        if let FileRequest::Resize { length, responder } = self {
            Some((length, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_backing_memory(self) -> Option<(VmoFlags, FileGetBackingMemoryResponder)> {
        if let FileRequest::GetBackingMemory { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_allocate(self) -> Option<(u64, u64, AllocateMode, FileAllocateResponder)> {
        if let FileRequest::Allocate { offset, length, mode, responder } = self {
            Some((offset, length, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_verity(self) -> Option<(VerificationOptions, FileEnableVerityResponder)> {
        if let FileRequest::EnableVerity { options, responder } = self {
            Some((options, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FileRequest::AdvisoryLock { .. } => "advisory_lock",
            FileRequest::LinkInto { .. } => "link_into",
            FileRequest::Clone { .. } => "clone",
            FileRequest::Close { .. } => "close",
            FileRequest::Query { .. } => "query",
            FileRequest::DeprecatedClone { .. } => "deprecated_clone",
            FileRequest::DeprecatedGetAttr { .. } => "deprecated_get_attr",
            FileRequest::DeprecatedSetAttr { .. } => "deprecated_set_attr",
            FileRequest::DeprecatedGetFlags { .. } => "deprecated_get_flags",
            FileRequest::DeprecatedSetFlags { .. } => "deprecated_set_flags",
            FileRequest::GetFlags { .. } => "get_flags",
            FileRequest::SetFlags { .. } => "set_flags",
            FileRequest::QueryFilesystem { .. } => "query_filesystem",
            FileRequest::GetAttributes { .. } => "get_attributes",
            FileRequest::UpdateAttributes { .. } => "update_attributes",
            FileRequest::Sync { .. } => "sync",
            FileRequest::ListExtendedAttributes { .. } => "list_extended_attributes",
            FileRequest::GetExtendedAttribute { .. } => "get_extended_attribute",
            FileRequest::SetExtendedAttribute { .. } => "set_extended_attribute",
            FileRequest::RemoveExtendedAttribute { .. } => "remove_extended_attribute",
            FileRequest::Read { .. } => "read",
            FileRequest::Write { .. } => "write",
            FileRequest::Describe { .. } => "describe",
            FileRequest::Seek { .. } => "seek",
            FileRequest::ReadAt { .. } => "read_at",
            FileRequest::WriteAt { .. } => "write_at",
            FileRequest::Resize { .. } => "resize",
            FileRequest::GetBackingMemory { .. } => "get_backing_memory",
            FileRequest::Allocate { .. } => "allocate",
            FileRequest::EnableVerity { .. } => "enable_verity",
            FileRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            FileRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for FileControlHandle {
    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 FileControlHandle {
    pub fn send_on_open_(
        &self,
        mut s: i32,
        mut info: Option<NodeInfoDeprecated>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<NodeOnOpenRequest>(
            (s, info.as_mut()),
            0,
            0x7fc7bbb1dbfd1972,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_representation(&self, mut payload: Representation) -> Result<(), fidl::Error> {
        self.inner.send::<Representation>(
            &mut payload,
            0,
            0x5cb40567d80a510c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fdomain_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut s: i32, mut attributes: &NodeAttributes) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut flags: OpenFlags) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<Flags, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|flags| (flags,))),
                self.tx_id,
                0x176eb318f64ec23,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut info: Option<&FilesystemInfo>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeQueryFilesystemResponse>(
            (s, info),
            self.tx_id,
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<ExtendedAttributeValue, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ExtendedAttributeValue, i32>>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ReadableReadResponse, i32>>(
            result.map(|data| (data,)),
            self.tx_id,
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<WritableWriteResponse, i32>>(
            result.map(|actual_count| (actual_count,)),
            self.tx_id,
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut payload: FileInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FileInfo>(
            &mut payload,
            self.tx_id,
            0x68b5ac00c62906bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<FileSeekResponse, i32>>(
            result.map(|offset_from_start| (offset_from_start,)),
            self.tx_id,
            0x78079168162c5207,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<FileReadAtResponse, i32>>(
            result.map(|data| (data,)),
            self.tx_id,
            0x1607a293a60d723e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<FileWriteAtResponse, i32>>(
            result.map(|actual_count| (actual_count,)),
            self.tx_id,
            0x793eefc0045e792b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fdomain_client::Vmo, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<FileGetBackingMemoryResponse, i32>>(
                result.map(|vmo| (vmo,)),
                self.tx_id,
                0xa6a9e654cbf62b,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for LinkableMarker {
    type Proxy = LinkableProxy;
    type RequestStream = LinkableRequestStream;

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

pub trait LinkableProxyInterface: Send + Sync {
    type LinkIntoResponseFut: std::future::Future<Output = Result<LinkableLinkIntoResult, fidl::Error>>
        + Send;
    fn r#link_into(
        &self,
        dst_parent_token: fdomain_client::Event,
        dst: &str,
    ) -> Self::LinkIntoResponseFut;
}

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

impl fdomain_client::fidl::Proxy for LinkableProxy {
    type Protocol = LinkableMarker;

    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 LinkableProxy {
    /// Create a new Proxy for fuchsia.io/Linkable.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <LinkableMarker 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) -> LinkableEventStream {
        LinkableEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    pub fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LinkableProxyInterface::r#link_into(self, dst_parent_token, dst)
    }
}

impl LinkableProxyInterface for LinkableProxy {
    type LinkIntoResponseFut = fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LinkableLinkIntoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x54f3949246a03e74,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<LinkableLinkIntoRequest, LinkableLinkIntoResult>(
            (dst_parent_token, dst),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl LinkableEvent {
    /// Decodes a message buffer as a [`LinkableEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<LinkableEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <LinkableMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for LinkableRequestStream {
    type Protocol = LinkableMarker;
    type ControlHandle = LinkableControlHandle;

    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 {
        LinkableControlHandle { 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 LinkableRequestStream {
    type Item = Result<LinkableRequest, 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 LinkableRequestStream 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 {
                    0x54f3949246a03e74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinkableLinkIntoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LinkableLinkIntoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LinkableControlHandle { inner: this.inner.clone() };
                        Ok(LinkableRequest::LinkInto {
                            dst_parent_token: req.dst_parent_token,
                            dst: req.dst,

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

#[derive(Debug)]
pub enum LinkableRequest {
    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    LinkInto {
        dst_parent_token: fdomain_client::Event,
        dst: String,
        responder: LinkableLinkIntoResponder,
    },
}

impl LinkableRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_link_into(
        self,
    ) -> Option<(fdomain_client::Event, String, LinkableLinkIntoResponder)> {
        if let LinkableRequest::LinkInto { dst_parent_token, dst, responder } = self {
            Some((dst_parent_token, dst, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for LinkableControlHandle {
    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 LinkableControlHandle {}

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

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

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

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

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

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

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

    const DEBUG_NAME: &'static str = "fuchsia.io.Node";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for NodeMarker {}
pub type NodeGetFlagsResult = Result<Flags, i32>;
pub type NodeSetFlagsResult = Result<(), i32>;
pub type NodeGetAttributesResult = Result<(MutableNodeAttributes, ImmutableNodeAttributes), i32>;
pub type NodeUpdateAttributesResult = Result<(), i32>;
pub type NodeSyncResult = Result<(), i32>;
pub type NodeGetExtendedAttributeResult = Result<ExtendedAttributeValue, i32>;
pub type NodeSetExtendedAttributeResult = Result<(), i32>;
pub type NodeRemoveExtendedAttributeResult = Result<(), i32>;

pub trait NodeProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    fn r#deprecated_clone(
        &self,
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type DeprecatedGetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut;
    type DeprecatedSetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#deprecated_set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut;
    type DeprecatedGetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut;
    type DeprecatedSetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#deprecated_set_flags(&self, flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<NodeGetFlagsResult, fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<NodeSetFlagsResult, fidl::Error>>
        + Send;
    fn r#set_flags(&self, flags: Flags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetAttributesResponseFut: std::future::Future<Output = Result<NodeGetAttributesResult, fidl::Error>>
        + Send;
    fn r#get_attributes(&self, query: NodeAttributesQuery) -> Self::GetAttributesResponseFut;
    type UpdateAttributesResponseFut: std::future::Future<Output = Result<NodeUpdateAttributesResult, fidl::Error>>
        + Send;
    fn r#update_attributes(
        &self,
        payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut;
    type SyncResponseFut: std::future::Future<Output = Result<NodeSyncResult, fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#list_extended_attributes(
        &self,
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type GetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeGetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#get_extended_attribute(&self, name: &[u8]) -> Self::GetExtendedAttributeResponseFut;
    type SetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeSetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#set_extended_attribute(
        &self,
        name: &[u8],
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut;
    type RemoveExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeRemoveExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#remove_extended_attribute(&self, name: &[u8]) -> Self::RemoveExtendedAttributeResponseFut;
}

#[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.io/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() }
    }

    pub fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect> {
        NodeProxyInterface::r#query(self)
    }

    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    pub fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#deprecated_clone(self, flags, object)
    }

    /// DEPRECATED - Use `Node.GetAttributes` instead.
    pub fn r#deprecated_get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#deprecated_get_attr(self)
    }

    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    pub fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        NodeProxyInterface::r#deprecated_set_attr(self, flags, attributes)
    }

    /// [DEPRECATED - Use new GetFlags method instead.]
    pub fn r#deprecated_get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#deprecated_get_flags(self)
    }

    /// [DEPRECATED - Use new SetFlags method instead.]
    pub fn r#deprecated_set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        NodeProxyInterface::r#deprecated_set_flags(self, flags)
    }

    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_flags(self)
    }

    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    pub fn r#set_flags(
        &self,
        mut flags: Flags,
    ) -> fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#set_flags(self, flags)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_attributes(
        &self,
        mut query: NodeAttributesQuery,
    ) -> fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_attributes(self, query)
    }

    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#update_attributes(self, payload)
    }

    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<NodeSyncResult, fdomain_client::fidl::FDomainResourceDialect>
    {
        NodeProxyInterface::r#sync(self)
    }

    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#list_extended_attributes(self, iterator)
    }

    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#get_extended_attribute(self, name)
    }

    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#set_extended_attribute(self, name, value, mode)
    }

    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NodeProxyInterface::r#remove_extended_attribute(self, name)
    }
}

impl NodeProxyInterface for NodeProxy {
    fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fdomain_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fdomain_fuchsia_unknown::QueryableQueryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeDeprecatedCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type DeprecatedGetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x78985e216314dafd,
            >(_buf?)?;
            Ok((_response.s, _response.attributes))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, NodeAttributes)>(
            (),
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedGetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b88fffb8eda3aa1,
            >(_buf?)?;
            Ok((_response.s, _response.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, OpenFlags)>(
            (),
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_flags(&self, mut flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x176eb318f64ec23,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("get_flags")?;
            Ok(_response.map(|x| x.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetFlagsResult>(
            (),
            0x176eb318f64ec23,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_flags(&self, mut flags: Flags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x55a8028685791ea8,
            >(_buf?)?
            .into_result_fdomain::<NodeMarker>("set_flags")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, NodeSetFlagsResult>(
            (flags,),
            0x55a8028685791ea8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6f344a1c6b0a0610,
            >(_buf?)?;
            Ok((_response.s, _response.info))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<FilesystemInfo>>),
        >(
            (),
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3d4396a638ea053b,
            >(_buf?)?;
            Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
        }
        self.client.send_query_and_decode::<NodeGetAttributesRequest, NodeGetAttributesResult>(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3308c1da5a89bf08,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MutableNodeAttributes, NodeUpdateAttributesResult>(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SyncResponseFut = fidl::client::QueryResponseFut<
        NodeSyncResult,
        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<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c5c27ca0ab5dc49,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeSyncResult>(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x45ffa3ccfdeb76db,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeGetExtendedAttributeRequest,
            NodeGetExtendedAttributeResult,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4a951362f681f23c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeSetExtendedAttributeRequest,
            NodeSetExtendedAttributeResult,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7a0b9f3a9bf9032d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeRemoveExtendedAttributeRequest,
            NodeRemoveExtendedAttributeResult,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for NodeEventStream {
    type Item = Result<NodeEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(NodeEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum NodeEvent {
    OnOpen_ {
        s: i32,
        info: Option<Box<NodeInfoDeprecated>>,
    },
    OnRepresentation {
        payload: Representation,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl NodeEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_open_(self) -> Option<(i32, Option<Box<NodeInfoDeprecated>>)> {
        if let NodeEvent::OnOpen_ { s, info } = self { Some((s, info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_representation(self) -> Option<Representation> {
        if let NodeEvent::OnRepresentation { payload } = self { Some((payload)) } else { None }
    }

    /// 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 {
            0x7fc7bbb1dbfd1972 => {
                let mut out = fidl::new_empty!(
                    NodeOnOpenRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeOnOpenRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((NodeEvent::OnOpen_ { s: out.s, info: out.info }))
            }
            0x5cb40567d80a510c => {
                let mut out =
                    fidl::new_empty!(Representation, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<Representation>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((NodeEvent::OnRepresentation { payload: out }))
            }
            _ 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.io/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 {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fdomain_fuchsia_unknown::CloneableCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        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::Close {
                            responder: NodeCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        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::Query {
                            responder: NodeQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a61678f293ce16f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::DeprecatedClone {
                            flags: req.flags,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x78985e216314dafd => {
                        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::DeprecatedGetAttr {
                            responder: NodeDeprecatedGetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4186c0f40d938f46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetAttrRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::DeprecatedSetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: NodeDeprecatedSetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b88fffb8eda3aa1 => {
                        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::DeprecatedGetFlags {
                            responder: NodeDeprecatedGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::DeprecatedSetFlags {
                            flags: req.flags,

                            responder: NodeDeprecatedSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x176eb318f64ec23 => {
                        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::GetFlags {
                            responder: NodeGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55a8028685791ea8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetFlags {
                            flags: req.flags,

                            responder: NodeSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f344a1c6b0a0610 => {
                        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::QueryFilesystem {
                            responder: NodeQueryFilesystemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d4396a638ea053b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::GetAttributes {
                            query: req.query,

                            responder: NodeGetAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3308c1da5a89bf08 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MutableNodeAttributes,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MutableNodeAttributes>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::UpdateAttributes {
                            payload: req,
                            responder: NodeUpdateAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c5c27ca0ab5dc49 => {
                        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,
                            },
                        })
                    }
                    0x4b61033de007fcd0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeListExtendedAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeListExtendedAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::ListExtendedAttributes {
                            iterator: req.iterator,

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

                            responder: NodeGetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a951362f681f23c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetExtendedAttribute {
                            name: req.name,
                            value: req.value,
                            mode: req.mode,

                            responder: NodeSetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a0b9f3a9bf9032d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeRemoveExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeRemoveExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::RemoveExtendedAttribute {
                            name: req.name,

                            responder: NodeRemoveExtendedAttributeResponder {
                                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(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,
                    }),
                }))
            },
        )
    }
}

/// Node defines the minimal interface for entities which can be accessed in a filesystem.
#[derive(Debug)]
pub enum NodeRequest {
    Clone {
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        control_handle: NodeControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: NodeCloseResponder,
    },
    Query {
        responder: NodeQueryResponder,
    },
    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    DeprecatedClone {
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
        control_handle: NodeControlHandle,
    },
    /// DEPRECATED - Use `Node.GetAttributes` instead.
    DeprecatedGetAttr {
        responder: NodeDeprecatedGetAttrResponder,
    },
    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    DeprecatedSetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: NodeDeprecatedSetAttrResponder,
    },
    /// [DEPRECATED - Use new GetFlags method instead.]
    DeprecatedGetFlags {
        responder: NodeDeprecatedGetFlagsResponder,
    },
    /// [DEPRECATED - Use new SetFlags method instead.]
    DeprecatedSetFlags {
        flags: OpenFlags,
        responder: NodeDeprecatedSetFlagsResponder,
    },
    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    GetFlags {
        responder: NodeGetFlagsResponder,
    },
    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    SetFlags {
        flags: Flags,
        responder: NodeSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: NodeQueryFilesystemResponder,
    },
    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetAttributes {
        query: NodeAttributesQuery,
        responder: NodeGetAttributesResponder,
    },
    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    UpdateAttributes {
        payload: MutableNodeAttributes,
        responder: NodeUpdateAttributesResponder,
    },
    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    Sync {
        responder: NodeSyncResponder,
    },
    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    ListExtendedAttributes {
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        control_handle: NodeControlHandle,
    },
    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetExtendedAttribute {
        name: Vec<u8>,
        responder: NodeGetExtendedAttributeResponder,
    },
    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    SetExtendedAttribute {
        name: Vec<u8>,
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
        responder: NodeSetExtendedAttributeResponder,
    },
    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    RemoveExtendedAttribute {
        name: Vec<u8>,
        responder: NodeRemoveExtendedAttributeResponder,
    },
    /// 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_clone(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        NodeControlHandle,
    )> {
        if let NodeRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_clone(
        self,
    ) -> Option<(OpenFlags, fdomain_client::fidl::ServerEnd<NodeMarker>, NodeControlHandle)> {
        if let NodeRequest::DeprecatedClone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, NodeDeprecatedSetAttrResponder)> {
        if let NodeRequest::DeprecatedSetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_flags(self) -> Option<(OpenFlags, NodeDeprecatedSetFlagsResponder)> {
        if let NodeRequest::DeprecatedSetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_flags(self) -> Option<(Flags, NodeSetFlagsResponder)> {
        if let NodeRequest::SetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_attributes(self) -> Option<(NodeAttributesQuery, NodeGetAttributesResponder)> {
        if let NodeRequest::GetAttributes { query, responder } = self {
            Some((query, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_attributes(
        self,
    ) -> Option<(MutableNodeAttributes, NodeUpdateAttributesResponder)> {
        if let NodeRequest::UpdateAttributes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[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_list_extended_attributes(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>, NodeControlHandle)>
    {
        if let NodeRequest::ListExtendedAttributes { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, NodeGetExtendedAttributeResponder)> {
        if let NodeRequest::GetExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_extended_attribute(
        self,
    ) -> Option<(
        Vec<u8>,
        ExtendedAttributeValue,
        SetExtendedAttributeMode,
        NodeSetExtendedAttributeResponder,
    )> {
        if let NodeRequest::SetExtendedAttribute { name, value, mode, responder } = self {
            Some((name, value, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, NodeRemoveExtendedAttributeResponder)> {
        if let NodeRequest::RemoveExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NodeRequest::Clone { .. } => "clone",
            NodeRequest::Close { .. } => "close",
            NodeRequest::Query { .. } => "query",
            NodeRequest::DeprecatedClone { .. } => "deprecated_clone",
            NodeRequest::DeprecatedGetAttr { .. } => "deprecated_get_attr",
            NodeRequest::DeprecatedSetAttr { .. } => "deprecated_set_attr",
            NodeRequest::DeprecatedGetFlags { .. } => "deprecated_get_flags",
            NodeRequest::DeprecatedSetFlags { .. } => "deprecated_set_flags",
            NodeRequest::GetFlags { .. } => "get_flags",
            NodeRequest::SetFlags { .. } => "set_flags",
            NodeRequest::QueryFilesystem { .. } => "query_filesystem",
            NodeRequest::GetAttributes { .. } => "get_attributes",
            NodeRequest::UpdateAttributes { .. } => "update_attributes",
            NodeRequest::Sync { .. } => "sync",
            NodeRequest::ListExtendedAttributes { .. } => "list_extended_attributes",
            NodeRequest::GetExtendedAttribute { .. } => "get_extended_attribute",
            NodeRequest::SetExtendedAttribute { .. } => "set_extended_attribute",
            NodeRequest::RemoveExtendedAttribute { .. } => "remove_extended_attribute",
            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 {
    pub fn send_on_open_(
        &self,
        mut s: i32,
        mut info: Option<NodeInfoDeprecated>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<NodeOnOpenRequest>(
            (s, info.as_mut()),
            0,
            0x7fc7bbb1dbfd1972,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_representation(&self, mut payload: Representation) -> Result<(), fidl::Error> {
        self.inner.send::<Representation>(
            &mut payload,
            0,
            0x5cb40567d80a510c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fdomain_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

    fn send_raw(&self, mut s: i32, mut attributes: &NodeAttributes) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut s: i32, mut flags: OpenFlags) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<Flags, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|flags| (flags,))),
                self.tx_id,
                0x176eb318f64ec23,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut info: Option<&FilesystemInfo>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeQueryFilesystemResponse>(
            (s, info),
            self.tx_id,
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<ExtendedAttributeValue, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ExtendedAttributeValue, i32>>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for ReadableMarker {
    type Proxy = ReadableProxy;
    type RequestStream = ReadableRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Readable";
}
pub type ReadableReadResult = Result<Vec<u8>, i32>;

pub trait ReadableProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<ReadableReadResult, fidl::Error>>
        + Send;
    fn r#read(&self, count: u64) -> Self::ReadResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ReadableProxy {
    type Protocol = ReadableMarker;

    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 ReadableProxy {
    /// Create a new Proxy for fuchsia.io/Readable.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <ReadableMarker 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) -> ReadableEventStream {
        ReadableEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reads up to 'count' bytes at the seek offset.
    /// The seek offset is moved forward by the number of bytes read.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that the seek offset
    ///   has reached the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that the
    ///   seek offset is already at or beyond the end of file, and no data could
    ///   be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually read anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    pub fn r#read(
        &self,
        mut count: u64,
    ) -> fidl::client::QueryResponseFut<
        ReadableReadResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ReadableProxyInterface::r#read(self, count)
    }
}

impl ReadableProxyInterface for ReadableProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        ReadableReadResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#read(&self, mut count: u64) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReadableReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReadableReadResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x57e419a298c8ede,
            >(_buf?)?;
            Ok(_response.map(|x| x.data))
        }
        self.client.send_query_and_decode::<ReadableReadRequest, ReadableReadResult>(
            (count,),
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl ReadableEvent {
    /// Decodes a message buffer as a [`ReadableEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ReadableEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ReadableMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for ReadableRequestStream {
    type Protocol = ReadableMarker;
    type ControlHandle = ReadableControlHandle;

    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 {
        ReadableControlHandle { 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 ReadableRequestStream {
    type Item = Result<ReadableRequest, 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 ReadableRequestStream 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 {
                    0x57e419a298c8ede => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ReadableReadRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ReadableReadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ReadableControlHandle { inner: this.inner.clone() };
                        Ok(ReadableRequest::Read {
                            count: req.count,

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

#[derive(Debug)]
pub enum ReadableRequest {
    /// Reads up to 'count' bytes at the seek offset.
    /// The seek offset is moved forward by the number of bytes read.
    ///
    /// ## Invariants
    ///
    /// * The returned `data.length` will never be greater than `count`.
    /// * If `data.length` is less than `count`, it means that the seek offset
    ///   has reached the end of file as part of this operation.
    /// * If `data.length` is zero while `count` is not, it means that the
    ///   seek offset is already at or beyond the end of file, and no data could
    ///   be read.
    /// * If `count` is zero, the server should perform all the checks ensuring
    ///   read access without actually read anything, and return an empty
    ///   `data` vector.
    ///
    /// This method requires the [`Rights.READ_BYTES`] right.
    ///
    /// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
    Read { count: u64, responder: ReadableReadResponder },
}

impl ReadableRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_read(self) -> Option<(u64, ReadableReadResponder)> {
        if let ReadableRequest::Read { count, responder } = self {
            Some((count, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for ReadableControlHandle {
    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 ReadableControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ReadableReadResponse, i32>>(
            result.map(|data| (data,)),
            self.tx_id,
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for SymlinkMarker {
    type Proxy = SymlinkProxy;
    type RequestStream = SymlinkRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.io.Symlink";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for SymlinkMarker {}

pub trait SymlinkProxyInterface: Send + Sync {
    type LinkIntoResponseFut: std::future::Future<Output = Result<LinkableLinkIntoResult, fidl::Error>>
        + Send;
    fn r#link_into(
        &self,
        dst_parent_token: fdomain_client::Event,
        dst: &str,
    ) -> Self::LinkIntoResponseFut;
    fn r#clone(
        &self,
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    fn r#deprecated_clone(
        &self,
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type DeprecatedGetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut;
    type DeprecatedSetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#deprecated_set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut;
    type DeprecatedGetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut;
    type DeprecatedSetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#deprecated_set_flags(&self, flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<NodeGetFlagsResult, fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<NodeSetFlagsResult, fidl::Error>>
        + Send;
    fn r#set_flags(&self, flags: Flags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetAttributesResponseFut: std::future::Future<Output = Result<NodeGetAttributesResult, fidl::Error>>
        + Send;
    fn r#get_attributes(&self, query: NodeAttributesQuery) -> Self::GetAttributesResponseFut;
    type UpdateAttributesResponseFut: std::future::Future<Output = Result<NodeUpdateAttributesResult, fidl::Error>>
        + Send;
    fn r#update_attributes(
        &self,
        payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut;
    type SyncResponseFut: std::future::Future<Output = Result<NodeSyncResult, fidl::Error>> + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    fn r#list_extended_attributes(
        &self,
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type GetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeGetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#get_extended_attribute(&self, name: &[u8]) -> Self::GetExtendedAttributeResponseFut;
    type SetExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeSetExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#set_extended_attribute(
        &self,
        name: &[u8],
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut;
    type RemoveExtendedAttributeResponseFut: std::future::Future<Output = Result<NodeRemoveExtendedAttributeResult, fidl::Error>>
        + Send;
    fn r#remove_extended_attribute(&self, name: &[u8]) -> Self::RemoveExtendedAttributeResponseFut;
    type DescribeResponseFut: std::future::Future<Output = Result<SymlinkInfo, fidl::Error>> + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
}

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

impl fdomain_client::fidl::Proxy for SymlinkProxy {
    type Protocol = SymlinkMarker;

    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 SymlinkProxy {
    /// Create a new Proxy for fuchsia.io/Symlink.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SymlinkMarker 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) -> SymlinkEventStream {
        SymlinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    pub fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#link_into(self, dst_parent_token, dst)
    }

    pub fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        SymlinkProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect> {
        SymlinkProxyInterface::r#query(self)
    }

    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    pub fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        SymlinkProxyInterface::r#deprecated_clone(self, flags, object)
    }

    /// DEPRECATED - Use `Node.GetAttributes` instead.
    pub fn r#deprecated_get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#deprecated_get_attr(self)
    }

    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    pub fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        SymlinkProxyInterface::r#deprecated_set_attr(self, flags, attributes)
    }

    /// [DEPRECATED - Use new GetFlags method instead.]
    pub fn r#deprecated_get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#deprecated_get_flags(self)
    }

    /// [DEPRECATED - Use new SetFlags method instead.]
    pub fn r#deprecated_set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        SymlinkProxyInterface::r#deprecated_set_flags(self, flags)
    }

    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#get_flags(self)
    }

    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    pub fn r#set_flags(
        &self,
        mut flags: Flags,
    ) -> fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#set_flags(self, flags)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_attributes(
        &self,
        mut query: NodeAttributesQuery,
    ) -> fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#get_attributes(self, query)
    }

    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#update_attributes(self, payload)
    }

    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<NodeSyncResult, fdomain_client::fidl::FDomainResourceDialect>
    {
        SymlinkProxyInterface::r#sync(self)
    }

    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        SymlinkProxyInterface::r#list_extended_attributes(self, iterator)
    }

    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    pub fn r#get_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#get_extended_attribute(self, name)
    }

    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#set_extended_attribute(self, name, value, mode)
    }

    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    pub fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SymlinkProxyInterface::r#remove_extended_attribute(self, name)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<SymlinkInfo, fdomain_client::fidl::FDomainResourceDialect>
    {
        SymlinkProxyInterface::r#describe(self)
    }
}

impl SymlinkProxyInterface for SymlinkProxy {
    type LinkIntoResponseFut = fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fdomain_client::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LinkableLinkIntoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x54f3949246a03e74,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<LinkableLinkIntoRequest, LinkableLinkIntoResult>(
            (dst_parent_token, dst),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#clone(
        &self,
        mut request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fdomain_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fdomain_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fdomain_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fdomain_fuchsia_unknown::QueryableQueryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#deprecated_clone(
        &self,
        mut flags: OpenFlags,
        mut object: fdomain_client::fidl::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeDeprecatedCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    type DeprecatedGetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_attr(&self) -> Self::DeprecatedGetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x78985e216314dafd,
            >(_buf?)?;
            Ok((_response.s, _response.attributes))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, NodeAttributes)>(
            (),
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::DeprecatedSetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetAttrResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedGetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#deprecated_get_flags(&self) -> Self::DeprecatedGetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedGetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5b88fffb8eda3aa1,
            >(_buf?)?;
            Ok((_response.s, _response.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, OpenFlags)>(
            (),
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeprecatedSetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#deprecated_set_flags(&self, mut flags: OpenFlags) -> Self::DeprecatedSetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeDeprecatedSetFlagsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeDeprecatedSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeGetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x176eb318f64ec23,
            >(_buf?)?
            .into_result_fdomain::<SymlinkMarker>("get_flags")?;
            Ok(_response.map(|x| x.flags))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeGetFlagsResult>(
            (),
            0x176eb318f64ec23,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetFlagsResponseFut = fidl::client::QueryResponseFut<
        NodeSetFlagsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_flags(&self, mut flags: Flags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x55a8028685791ea8,
            >(_buf?)?
            .into_result_fdomain::<SymlinkMarker>("set_flags")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, NodeSetFlagsResult>(
            (flags,),
            0x55a8028685791ea8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6f344a1c6b0a0610,
            >(_buf?)?;
            Ok((_response.s, _response.info))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<FilesystemInfo>>),
        >(
            (),
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3d4396a638ea053b,
            >(_buf?)?;
            Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
        }
        self.client.send_query_and_decode::<NodeGetAttributesRequest, NodeGetAttributesResult>(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeUpdateAttributesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3308c1da5a89bf08,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MutableNodeAttributes, NodeUpdateAttributesResult>(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SyncResponseFut = fidl::client::QueryResponseFut<
        NodeSyncResult,
        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<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c5c27ca0ab5dc49,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, NodeSyncResult>(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#list_extended_attributes(
        &self,
        mut iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x45ffa3ccfdeb76db,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeGetExtendedAttributeRequest,
            NodeGetExtendedAttributeResult,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeSetExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4a951362f681f23c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeSetExtendedAttributeRequest,
            NodeSetExtendedAttributeResult,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeRemoveExtendedAttributeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7a0b9f3a9bf9032d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeRemoveExtendedAttributeRequest,
            NodeRemoveExtendedAttributeResult,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

#[derive(Debug)]
pub enum SymlinkEvent {
    OnOpen_ {
        s: i32,
        info: Option<Box<NodeInfoDeprecated>>,
    },
    OnRepresentation {
        payload: Representation,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl SymlinkEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_open_(self) -> Option<(i32, Option<Box<NodeInfoDeprecated>>)> {
        if let SymlinkEvent::OnOpen_ { s, info } = self { Some((s, info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_representation(self) -> Option<Representation> {
        if let SymlinkEvent::OnRepresentation { payload } = self { Some((payload)) } else { None }
    }

    /// Decodes a message buffer as a [`SymlinkEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SymlinkEvent, 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 {
            0x7fc7bbb1dbfd1972 => {
                let mut out = fidl::new_empty!(
                    NodeOnOpenRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeOnOpenRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SymlinkEvent::OnOpen_ { s: out.s, info: out.info }))
            }
            0x5cb40567d80a510c => {
                let mut out =
                    fidl::new_empty!(Representation, fdomain_client::fidl::FDomainResourceDialect);
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<Representation>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SymlinkEvent::OnRepresentation { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SymlinkEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <SymlinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for SymlinkRequestStream {
    type Protocol = SymlinkMarker;
    type ControlHandle = SymlinkControlHandle;

    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 {
        SymlinkControlHandle { 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 SymlinkRequestStream {
    type Item = Result<SymlinkRequest, 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 SymlinkRequestStream 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 {
                    0x54f3949246a03e74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinkableLinkIntoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LinkableLinkIntoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::LinkInto {
                            dst_parent_token: req.dst_parent_token,
                            dst: req.dst,

                            responder: SymlinkLinkIntoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fdomain_fuchsia_unknown::CloneableCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fdomain_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Close {
                            responder: SymlinkCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Query {
                            responder: SymlinkQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a61678f293ce16f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedCloneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::DeprecatedClone {
                            flags: req.flags,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x78985e216314dafd => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::DeprecatedGetAttr {
                            responder: SymlinkDeprecatedGetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4186c0f40d938f46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetAttrRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::DeprecatedSetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: SymlinkDeprecatedSetAttrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b88fffb8eda3aa1 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::DeprecatedGetFlags {
                            responder: SymlinkDeprecatedGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeDeprecatedSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeDeprecatedSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::DeprecatedSetFlags {
                            flags: req.flags,

                            responder: SymlinkDeprecatedSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x176eb318f64ec23 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::GetFlags {
                            responder: SymlinkGetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55a8028685791ea8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::SetFlags {
                            flags: req.flags,

                            responder: SymlinkSetFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f344a1c6b0a0610 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::QueryFilesystem {
                            responder: SymlinkQueryFilesystemResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d4396a638ea053b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::GetAttributes {
                            query: req.query,

                            responder: SymlinkGetAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3308c1da5a89bf08 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MutableNodeAttributes,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MutableNodeAttributes>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::UpdateAttributes {
                            payload: req,
                            responder: SymlinkUpdateAttributesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c5c27ca0ab5dc49 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Sync {
                            responder: SymlinkSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4b61033de007fcd0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NodeListExtendedAttributesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeListExtendedAttributesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::ListExtendedAttributes {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x45ffa3ccfdeb76db => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeGetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeGetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::GetExtendedAttribute {
                            name: req.name,

                            responder: SymlinkGetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a951362f681f23c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeSetExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::SetExtendedAttribute {
                            name: req.name,
                            value: req.value,
                            mode: req.mode,

                            responder: SymlinkSetExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a0b9f3a9bf9032d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeRemoveExtendedAttributeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NodeRemoveExtendedAttributeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::RemoveExtendedAttribute {
                            name: req.name,

                            responder: SymlinkRemoveExtendedAttributeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x742c2ea5e89831f3 => {
                        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 = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Describe {
                            responder: SymlinkDescribeResponder {
                                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(SymlinkRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SymlinkControlHandle { 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(SymlinkRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SymlinkControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SymlinkMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A ['Node'] which contains a symbolic link.
#[derive(Debug)]
pub enum SymlinkRequest {
    /// Creates a link to this this object with name `dst` in the directory represented by
    /// `dst_parent_token`.
    ///
    /// `dst` must be a resolved object name. Including "/" in the string will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// This method requires the maximal set of rights supported by the filesystem for this object.
    /// For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],
    /// [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also
    /// support the [`Rights.EXECUTE`] right. Insufficient rights will result in
    /// `ZX_ERR_ACCESS_DENIED`.
    ///
    /// If this object has no links and is *NOT* an unnamed temporary object (objects opened with
    /// `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,
    /// the object will be permanently linked to the filesystem. Requires that the unnamed temporary
    /// object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.
    ///
    /// This method does not have the same atomicity properties has the `Directory::Link` method,
    /// which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`
    /// because `LinkInto` will not prevent the source from being renamed or unlinked.
    LinkInto {
        dst_parent_token: fdomain_client::Event,
        dst: String,
        responder: SymlinkLinkIntoResponder,
    },
    Clone {
        request: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        control_handle: SymlinkControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: SymlinkCloseResponder,
    },
    Query {
        responder: SymlinkQueryResponder,
    },
    /// DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.
    DeprecatedClone {
        flags: OpenFlags,
        object: fdomain_client::fidl::ServerEnd<NodeMarker>,
        control_handle: SymlinkControlHandle,
    },
    /// DEPRECATED - Use `Node.GetAttributes` instead.
    DeprecatedGetAttr {
        responder: SymlinkDeprecatedGetAttrResponder,
    },
    /// DEPRECATED - Use `Node.UpdateAttributes` instead.
    DeprecatedSetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: SymlinkDeprecatedSetAttrResponder,
    },
    /// [DEPRECATED - Use new GetFlags method instead.]
    DeprecatedGetFlags {
        responder: SymlinkDeprecatedGetFlagsResponder,
    },
    /// [DEPRECATED - Use new SetFlags method instead.]
    DeprecatedSetFlags {
        flags: OpenFlags,
        responder: SymlinkDeprecatedSetFlagsResponder,
    },
    /// Queries the flags that apply to this node after it has been opened/created. This method does
    /// not require any rights.
    ///
    /// Note that the final set of flags that apply to the connection may differ from those
    /// specified with the `fuchsia.io/Directory.Open` request used to create it:
    ///  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.
    ///  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.
    ///  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.
    GetFlags {
        responder: SymlinkGetFlagsResponder,
    },
    /// Sets the flags that apply to this node after it has been opened. This method does not
    /// require any rights.
    ///
    /// Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will
    /// clear append mode.
    ///
    /// Errors:
    ///  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.
    ///  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.
    SetFlags {
        flags: Flags,
        responder: SymlinkSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: SymlinkQueryFilesystemResponder,
    },
    /// Acquires information about the node.
    ///
    /// The attributes of a node should be stable, independent of the
    /// specific protocol used to access it.
    ///
    /// If a particular attribute is not applicable or not supported,
    /// filesystems should leave the corresponding field absent.
    ///
    /// + `query` a bit-mask specifying which attributes to fetch. The server
    ///   should not return more than necessary.
    /// - `attributes` the returned attributes.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetAttributes {
        query: NodeAttributesQuery,
        responder: SymlinkGetAttributesResponder,
    },
    /// Updates information about the node.
    ///
    /// + `attributes` the presence of a table field in `attributes` indicates
    /// the intent to update the corresponding attribute.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    UpdateAttributes {
        payload: MutableNodeAttributes,
        responder: SymlinkUpdateAttributesResponder,
    },
    /// Synchronizes updates to the node to the underlying media, if it exists.
    ///
    /// This method will return when the filesystem server has flushed the
    /// relevant updates to the underlying media, but does not guarantee the
    /// underlying media has persisted the information, nor that any information
    /// is committed to hardware. Clients may use `Sync` to ensure ordering
    /// between operations.
    ///
    /// This method does not require any rights.
    Sync {
        responder: SymlinkSyncResponder,
    },
    /// Creates an iterator over all the extended attribute names associated
    /// with this node. If an error occurs it is returned as an epitaph on the
    /// iterator request channel, and then the channel is closed.
    ///
    /// GetExtendedAttributes can be used with any of these names to retrieve
    /// the associated value.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    ListExtendedAttributes {
        iterator: fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        control_handle: SymlinkControlHandle,
    },
    /// Get the value associated with the given attribute `name` for this node.
    ///
    /// Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No
    /// particular structure is imposed on them.
    ///
    /// This method requires the [`Rights.GET_ATTRIBUTES`] right.
    GetExtendedAttribute {
        name: Vec<u8>,
        responder: SymlinkGetExtendedAttributeResponder,
    },
    /// Set the value for the given attribute `name` to `value` for this node.
    ///
    /// The attribute name may exist, in which case the attribute is updated.
    /// If the attribute doesn't exist, it is created. The name should have no
    /// null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    SetExtendedAttribute {
        name: Vec<u8>,
        value: ExtendedAttributeValue,
        mode: SetExtendedAttributeMode,
        responder: SymlinkSetExtendedAttributeResponder,
    },
    /// Remove the specified extended attribute.
    ///
    /// If the attribute doesn't exist, ZX_ERR_NOT_FOUND is returned.
    ///
    /// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
    RemoveExtendedAttribute {
        name: Vec<u8>,
        responder: SymlinkRemoveExtendedAttributeResponder,
    },
    Describe {
        responder: SymlinkDescribeResponder,
    },
    /// 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: SymlinkControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SymlinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_link_into(
        self,
    ) -> Option<(fdomain_client::Event, String, SymlinkLinkIntoResponder)> {
        if let SymlinkRequest::LinkInto { dst_parent_token, dst, responder } = self {
            Some((dst_parent_token, dst, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_unknown::CloneableMarker>,
        SymlinkControlHandle,
    )> {
        if let SymlinkRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(SymlinkQueryResponder)> {
        if let SymlinkRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_clone(
        self,
    ) -> Option<(OpenFlags, fdomain_client::fidl::ServerEnd<NodeMarker>, SymlinkControlHandle)>
    {
        if let SymlinkRequest::DeprecatedClone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_attr(self) -> Option<(SymlinkDeprecatedGetAttrResponder)> {
        if let SymlinkRequest::DeprecatedGetAttr { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, SymlinkDeprecatedSetAttrResponder)> {
        if let SymlinkRequest::DeprecatedSetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_get_flags(self) -> Option<(SymlinkDeprecatedGetFlagsResponder)> {
        if let SymlinkRequest::DeprecatedGetFlags { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deprecated_set_flags(
        self,
    ) -> Option<(OpenFlags, SymlinkDeprecatedSetFlagsResponder)> {
        if let SymlinkRequest::DeprecatedSetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_flags(self) -> Option<(SymlinkGetFlagsResponder)> {
        if let SymlinkRequest::GetFlags { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_flags(self) -> Option<(Flags, SymlinkSetFlagsResponder)> {
        if let SymlinkRequest::SetFlags { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_filesystem(self) -> Option<(SymlinkQueryFilesystemResponder)> {
        if let SymlinkRequest::QueryFilesystem { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_attributes(
        self,
    ) -> Option<(NodeAttributesQuery, SymlinkGetAttributesResponder)> {
        if let SymlinkRequest::GetAttributes { query, responder } = self {
            Some((query, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_attributes(
        self,
    ) -> Option<(MutableNodeAttributes, SymlinkUpdateAttributesResponder)> {
        if let SymlinkRequest::UpdateAttributes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_extended_attributes(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
        SymlinkControlHandle,
    )> {
        if let SymlinkRequest::ListExtendedAttributes { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, SymlinkGetExtendedAttributeResponder)> {
        if let SymlinkRequest::GetExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_extended_attribute(
        self,
    ) -> Option<(
        Vec<u8>,
        ExtendedAttributeValue,
        SetExtendedAttributeMode,
        SymlinkSetExtendedAttributeResponder,
    )> {
        if let SymlinkRequest::SetExtendedAttribute { name, value, mode, responder } = self {
            Some((name, value, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_extended_attribute(
        self,
    ) -> Option<(Vec<u8>, SymlinkRemoveExtendedAttributeResponder)> {
        if let SymlinkRequest::RemoveExtendedAttribute { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(SymlinkDescribeResponder)> {
        if let SymlinkRequest::Describe { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SymlinkRequest::LinkInto { .. } => "link_into",
            SymlinkRequest::Clone { .. } => "clone",
            SymlinkRequest::Close { .. } => "close",
            SymlinkRequest::Query { .. } => "query",
            SymlinkRequest::DeprecatedClone { .. } => "deprecated_clone",
            SymlinkRequest::DeprecatedGetAttr { .. } => "deprecated_get_attr",
            SymlinkRequest::DeprecatedSetAttr { .. } => "deprecated_set_attr",
            SymlinkRequest::DeprecatedGetFlags { .. } => "deprecated_get_flags",
            SymlinkRequest::DeprecatedSetFlags { .. } => "deprecated_set_flags",
            SymlinkRequest::GetFlags { .. } => "get_flags",
            SymlinkRequest::SetFlags { .. } => "set_flags",
            SymlinkRequest::QueryFilesystem { .. } => "query_filesystem",
            SymlinkRequest::GetAttributes { .. } => "get_attributes",
            SymlinkRequest::UpdateAttributes { .. } => "update_attributes",
            SymlinkRequest::Sync { .. } => "sync",
            SymlinkRequest::ListExtendedAttributes { .. } => "list_extended_attributes",
            SymlinkRequest::GetExtendedAttribute { .. } => "get_extended_attribute",
            SymlinkRequest::SetExtendedAttribute { .. } => "set_extended_attribute",
            SymlinkRequest::RemoveExtendedAttribute { .. } => "remove_extended_attribute",
            SymlinkRequest::Describe { .. } => "describe",
            SymlinkRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            SymlinkRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for SymlinkControlHandle {
    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 SymlinkControlHandle {
    pub fn send_on_open_(
        &self,
        mut s: i32,
        mut info: Option<NodeInfoDeprecated>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<NodeOnOpenRequest>(
            (s, info.as_mut()),
            0,
            0x7fc7bbb1dbfd1972,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_representation(&self, mut payload: Representation) -> Result<(), fidl::Error> {
        self.inner.send::<Representation>(
            &mut payload,
            0,
            0x5cb40567d80a510c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fdomain_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut s: i32, mut attributes: &NodeAttributes) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut flags: OpenFlags) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeDeprecatedGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<Flags, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<NodeGetFlagsResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|flags| (flags,))),
                self.tx_id,
                0x176eb318f64ec23,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut s: i32, mut info: Option<&FilesystemInfo>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NodeQueryFilesystemResponse>(
            (s, info),
            self.tx_id,
            0x6f344a1c6b0a0610,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<ExtendedAttributeValue, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ExtendedAttributeValue, i32>>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for WritableMarker {
    type Proxy = WritableProxy;
    type RequestStream = WritableRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Writable";
}
pub type WritableWriteResult = Result<u64, i32>;

pub trait WritableProxyInterface: Send + Sync {
    type WriteResponseFut: std::future::Future<Output = Result<WritableWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, data: &[u8]) -> Self::WriteResponseFut;
}

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

impl fdomain_client::fidl::Proxy for WritableProxy {
    type Protocol = WritableMarker;

    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 WritableProxy {
    /// Create a new Proxy for fuchsia.io/Writable.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <WritableMarker 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) -> WritableEventStream {
        WritableEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Writes data at the seek offset.
    /// The seek offset is moved forward by the number of bytes written.
    /// If the file is in append mode, the seek offset is first set to the end
    /// of the file, followed by the write, in one atomic step.
    ///
    /// The file size may grow if the seek offset plus `data.length` is beyond
    /// the current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file and return a
    ///   successful write of zero bytes.  The seek offset is still updated if
    ///   in append mode.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    pub fn r#write(
        &self,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        WritableWriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        WritableProxyInterface::r#write(self, data)
    }
}

impl WritableProxyInterface for WritableProxy {
    type WriteResponseFut = fidl::client::QueryResponseFut<
        WritableWriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WritableWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WritableWriteResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6a31437832469f82,
            >(_buf?)?;
            Ok(_response.map(|x| x.actual_count))
        }
        self.client.send_query_and_decode::<WritableWriteRequest, WritableWriteResult>(
            (data,),
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

impl WritableEvent {
    /// Decodes a message buffer as a [`WritableEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WritableEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <WritableMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for WritableRequestStream {
    type Protocol = WritableMarker;
    type ControlHandle = WritableControlHandle;

    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 {
        WritableControlHandle { 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 WritableRequestStream {
    type Item = Result<WritableRequest, 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 WritableRequestStream 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 {
                    0x6a31437832469f82 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WritableWriteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<WritableWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = WritableControlHandle { inner: this.inner.clone() };
                        Ok(WritableRequest::Write {
                            data: req.data,

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

#[derive(Debug)]
pub enum WritableRequest {
    /// Writes data at the seek offset.
    /// The seek offset is moved forward by the number of bytes written.
    /// If the file is in append mode, the seek offset is first set to the end
    /// of the file, followed by the write, in one atomic step.
    ///
    /// The file size may grow if the seek offset plus `data.length` is beyond
    /// the current end of file.
    ///
    /// + request `data` the byte buffer to write to the file.
    /// - response `actual_count` the number of bytes written.
    ///
    /// ## Invariants
    ///
    /// * The returned `actual_count` will never be greater than `data.length`.
    /// * If the server is unable to write all the data due to e.g. not enough
    ///   space, `actual_count` may be less than `data.length`.  If no bytes
    ///   could be written, an error is returned.
    /// * If `data.length` is zero, the server should perform all the checks
    ///   ensuring write access without mutating the file and return a
    ///   successful write of zero bytes.  The seek offset is still updated if
    ///   in append mode.
    ///
    /// This method requires the [`Rights.WRITE_BYTES`] right.
    Write { data: Vec<u8>, responder: WritableWriteResponder },
}

impl WritableRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(Vec<u8>, WritableWriteResponder)> {
        if let WritableRequest::Write { data, responder } = self {
            Some((data, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for WritableControlHandle {
    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 WritableControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<WritableWriteResponse, i32>>(
            result.map(|actual_count| (actual_count,)),
            self.tx_id,
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DirectoryCreateSymlinkRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DirectoryCreateSymlinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryCreateSymlinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryCreateSymlinkRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.target,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.connection
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Vector<u8, 4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DirectoryCreateSymlinkRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryCreateSymlinkRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryCreateSymlinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                target: fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, fdomain_client::fidl::FDomainResourceDialect),
                connection: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 4095>, fdomain_client::fidl::FDomainResourceDialect, &mut self.target, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SymlinkMarker>>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.connection,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DirectoryDeprecatedOpenRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DirectoryDeprecatedOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryDeprecatedOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryDeprecatedOpenRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <OpenFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                    <ModeType as fidl::encoding::ValueTypeMarker>::borrow(&self.mode),
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<OpenFlags, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<ModeType, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DirectoryDeprecatedOpenRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryDeprecatedOpenRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryDeprecatedOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                flags: fidl::new_empty!(OpenFlags, fdomain_client::fidl::FDomainResourceDialect),
                mode: fidl::new_empty!(ModeType, fdomain_client::fidl::FDomainResourceDialect),
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                OpenFlags,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.flags,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ModeType,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.mode,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.path,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.object,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DirectoryGetTokenResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut DirectoryGetTokenResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryGetTokenResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryGetTokenResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.token
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DirectoryGetTokenResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryGetTokenResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryGetTokenResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect),
                token: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                i32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.s,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.token,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DirectoryLinkRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DirectoryLinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryLinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryLinkRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.src,
                    ),
                    <fidl::encoding::HandleType<
                        fdomain_client::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dst_parent_token,
                    ),
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.dst,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<DirectoryLinkRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryLinkRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryLinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.src,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.dst_parent_token, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dst,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DirectoryOpenRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DirectoryOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryOpenRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <Flags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                    <Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<Flags, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<Options, fdomain_client::fidl::FDomainResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<DirectoryOpenRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpenRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 40, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                flags: fidl::new_empty!(Flags, fdomain_client::fidl::FDomainResourceDialect),
                options: fidl::new_empty!(Options, fdomain_client::fidl::FDomainResourceDialect),
                object: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Flags,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.flags,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                Options,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.options,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.object, decoder, offset + 40, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DirectoryRenameRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DirectoryRenameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryRenameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryRenameRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.src,
                    ),
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dst_parent_token,
                    ),
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.dst,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<DirectoryRenameRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryRenameRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryRenameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.src,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.dst_parent_token, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dst,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DirectoryWatchRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DirectoryWatchRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryWatchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryWatchRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <WatchMask as fidl::encoding::ValueTypeMarker>::borrow(&self.mask),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.watcher
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<WatchMask, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<DirectoryWatchRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryWatchRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for DirectoryWatchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mask: fidl::new_empty!(WatchMask, fdomain_client::fidl::FDomainResourceDialect),
                options: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<DirectoryWatcherMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<FileAllocateRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut FileAllocateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileAllocateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileAllocateRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.offset),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.length),
                    <AllocateMode as fidl::encoding::ValueTypeMarker>::borrow(&self.mode),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<AllocateMode, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<FileAllocateRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileAllocateRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for FileAllocateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                offset: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                length: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                mode: fidl::new_empty!(AllocateMode, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for FileEnableVerityRequest {
        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 FileEnableVerityRequest {
        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<
            FileEnableVerityRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut FileEnableVerityRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileEnableVerityRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileEnableVerityRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<VerificationOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<VerificationOptions, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            FileEnableVerityRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileEnableVerityRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    unsafe impl fidl::encoding::Encode<FileObject, fdomain_client::fidl::FDomainResourceDialect>
        for &mut FileObject
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileObject>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileObject, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.event),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fdomain_client::Stream, { fidl::ObjectType::STREAM.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.stream),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Stream,
                        { fidl::ObjectType::STREAM.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<FileObject, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileObject>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for FileObject {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                event: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                stream: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Stream,
                            { fidl::ObjectType::STREAM.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.event,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Stream,
                        { fidl::ObjectType::STREAM.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.stream,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FileGetBackingMemoryResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut FileGetBackingMemoryResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileGetBackingMemoryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileGetBackingMemoryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vmo
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FileGetBackingMemoryResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileGetBackingMemoryResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for FileGetBackingMemoryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.vmo, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            LinkableLinkIntoRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LinkableLinkIntoRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LinkableLinkIntoRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LinkableLinkIntoRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dst_parent_token,
                    ),
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.dst,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LinkableLinkIntoRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LinkableLinkIntoRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LinkableLinkIntoRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.dst_parent_token, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dst,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NodeDeprecatedCloneRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NodeDeprecatedCloneRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeDeprecatedCloneRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeDeprecatedCloneRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <OpenFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<OpenFlags, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NodeDeprecatedCloneRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeDeprecatedCloneRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeDeprecatedCloneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                flags: fidl::new_empty!(OpenFlags, fdomain_client::fidl::FDomainResourceDialect),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<NodeMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NodeListExtendedAttributesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NodeListExtendedAttributesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeListExtendedAttributesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NodeListExtendedAttributesRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.iterator
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NodeListExtendedAttributesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeListExtendedAttributesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeListExtendedAttributesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<ExtendedAttributeIteratorMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<NodeOnOpenRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NodeOnOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeOnOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeOnOpenRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <fidl::encoding::OptionalUnion<NodeInfoDeprecated> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<NodeInfoDeprecated>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<NodeOnOpenRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeOnOpenRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeOnOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect),
                info: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<NodeInfoDeprecated>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NodeSetExtendedAttributeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NodeSetExtendedAttributeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetExtendedAttributeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NodeSetExtendedAttributeRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <ExtendedAttributeValue as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.value,
                    ),
                    <SetExtendedAttributeMode as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.mode,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<u8, 255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                ExtendedAttributeValue,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                SetExtendedAttributeMode,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NodeSetExtendedAttributeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetExtendedAttributeRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for NodeSetExtendedAttributeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::Vector<u8, 255>, fdomain_client::fidl::FDomainResourceDialect),
                value: fidl::new_empty!(
                    ExtendedAttributeValue,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                mode: fidl::new_empty!(
                    SetExtendedAttributeMode,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Vector<u8, 255>, fdomain_client::fidl::FDomainResourceDialect, &mut self.name, decoder, offset + 0, _depth)?;
            fidl::decode!(
                ExtendedAttributeValue,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.value,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                SetExtendedAttributeMode,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.mode,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for ConnectionInfo {
        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 ConnectionInfo {
        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<ConnectionInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut ConnectionInfo
    {
        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::<ConnectionInfo>(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::<
                Operations,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.rights.as_ref().map(<Operations 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 ConnectionInfo {
        #[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 =
                    <Operations 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.get_or_insert_with(|| {
                    fidl::new_empty!(Operations, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Operations,
                    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 FileInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.attributes {
                return 4;
            }
            if let Some(_) = self.stream {
                return 3;
            }
            if let Some(_) = self.observer {
                return 2;
            }
            if let Some(_) = self.is_append {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FileInfo {
        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 FileInfo {
        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<FileInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut FileInfo
    {
        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::<FileInfo>(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.is_append.as_ref().map(<bool 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::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.observer.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;
            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::Stream,
                    { fidl::ObjectType::STREAM.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.stream.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Stream,
                        { fidl::ObjectType::STREAM.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                NodeAttributes2,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.attributes
                    .as_ref()
                    .map(<NodeAttributes2 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 FileInfo {
        #[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.is_append.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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::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.observer.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;
            _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::Stream,
                    { fidl::ObjectType::STREAM.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.stream.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Stream, { fidl::ObjectType::STREAM.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Stream, { fidl::ObjectType::STREAM.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 < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <NodeAttributes2 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.attributes.get_or_insert_with(|| {
                    fidl::new_empty!(NodeAttributes2, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    NodeAttributes2,
                    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 fidl::encoding::ResourceTypeMarker for ExtendedAttributeValue {
        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 ExtendedAttributeValue {
        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<ExtendedAttributeValue, fdomain_client::fidl::FDomainResourceDialect>
        for &mut ExtendedAttributeValue
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExtendedAttributeValue>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ExtendedAttributeValue::Bytes(ref val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Vector<u8, 32768>,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <fidl::encoding::Vector<u8, 32768> as fidl::encoding::ValueTypeMarker>::borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ExtendedAttributeValue::Buffer(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ExtendedAttributeValue::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

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

        #[inline]
        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);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => {
                    <fidl::encoding::Vector<u8, 32768> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    )
                }
                2 => <fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Bytes(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ExtendedAttributeValue::Bytes(
                            fidl::new_empty!(fidl::encoding::Vector<u8, 32768>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Bytes(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<u8, 32768>, fdomain_client::fidl::FDomainResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Buffer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ExtendedAttributeValue::Buffer(
                            fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Buffer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = ExtendedAttributeValue::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            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);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NodeInfoDeprecated {
        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 NodeInfoDeprecated {
        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<NodeInfoDeprecated, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NodeInfoDeprecated
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeInfoDeprecated>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                NodeInfoDeprecated::Service(ref val) => fidl::encoding::encode_in_envelope::<
                    Service,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::File(ref mut val) => fidl::encoding::encode_in_envelope::<
                    FileObject,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <FileObject as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::Directory(ref val) => fidl::encoding::encode_in_envelope::<
                    DirectoryObject,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <DirectoryObject as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::Symlink(ref val) => fidl::encoding::encode_in_envelope::<
                    SymlinkObject,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <SymlinkObject as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

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

        #[inline]
        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);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <FileObject as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <DirectoryObject as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <SymlinkObject as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Service(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NodeInfoDeprecated::Service(fidl::new_empty!(
                            Service,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Service(ref mut val) = self {
                        fidl::decode!(
                            Service,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::File(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NodeInfoDeprecated::File(fidl::new_empty!(
                            FileObject,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::File(ref mut val) = self {
                        fidl::decode!(
                            FileObject,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Directory(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NodeInfoDeprecated::Directory(fidl::new_empty!(
                            DirectoryObject,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Directory(ref mut val) = self {
                        fidl::decode!(
                            DirectoryObject,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Symlink(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NodeInfoDeprecated::Symlink(fidl::new_empty!(
                            SymlinkObject,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Symlink(ref mut val) = self {
                        fidl::decode!(
                            SymlinkObject,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            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);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Representation {
        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 Representation {
        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<Representation, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Representation
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Representation>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                Representation::Node(ref val) => fidl::encoding::encode_in_envelope::<
                    NodeInfo,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <NodeInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::Directory(ref val) => fidl::encoding::encode_in_envelope::<
                    DirectoryInfo,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <DirectoryInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::File(ref mut val) => fidl::encoding::encode_in_envelope::<
                    FileInfo,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <FileInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::Symlink(ref val) => fidl::encoding::encode_in_envelope::<
                    SymlinkInfo,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <SymlinkInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

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

        #[inline]
        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);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <NodeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <DirectoryInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FileInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <SymlinkInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Node(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Representation::Node(fidl::new_empty!(
                            NodeInfo,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Node(ref mut val) = self {
                        fidl::decode!(
                            NodeInfo,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Directory(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Representation::Directory(fidl::new_empty!(
                            DirectoryInfo,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Directory(ref mut val) = self {
                        fidl::decode!(
                            DirectoryInfo,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::File(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Representation::File(fidl::new_empty!(
                            FileInfo,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::File(ref mut val) = self {
                        fidl::decode!(
                            FileInfo,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Symlink(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Representation::Symlink(fidl::new_empty!(
                            SymlinkInfo,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Symlink(ref mut val) = self {
                        fidl::decode!(
                            SymlinkInfo,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = Representation::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            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);
            }
            Ok(())
        }
    }
}