// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Abilities are properties intrinsic to a node. They specify which operations are supported by it.
///
/// Invoking an operation on a node that does not support it results in `ZX_ERR_NOT_SUPPORTED`.
/// Note `ZX_ERR_ACCESS_DENIED` takes precedence over `ZX_ERR_NOT_SUPPORTED` when both apply.
pub type Abilities = Operations;

/// The name of an extended attribute. It can not contain any null bytes. Other
/// than that and the maximum size, no particular structure is imposed on the
/// name.
pub type ExtendedAttributeName = Vec<u8>;

/// The type to identify a node, if the implementation supports some notion of
/// unique node ID.
///
/// ## Uniqueness Guarantees
///
/// A client is usually presented with a directory tree that is the result
/// of composing together multiple backing implementation instances. An ID
/// would be unique within the corresponding instance only.
/// Their boundaries are rather implicit on Fuchsia, as a result of
/// transparently-forwarding directory proxies. It could be common for a client
/// to observe identical `Id`s when traversing a directory tree, when it
/// encounters nodes from different backing instances. Therefore, the ID is best
/// used for debugging and informational purposes.
///
/// The [`fuchsia.fs/FilesystemInfo.fs_id`] field may be used to disambiguate
/// IDs from different backing instances.
pub type Id = u64;

/// The type for the name of a node, i.e. a single path component.
/// E.g. `foo`
///
/// ## Invariants
///
/// A valid node name must meet the following criteria:
///
/// * It cannot be longer than [`MAX_NAME_LENGTH`].
/// * It cannot be empty.
/// * It cannot be ".." (dot-dot).
/// * It cannot be "." (single dot).
/// * It cannot contain "/".
/// * It cannot contain embedded NUL.
pub type Name = String;

/// A path is a string of one or more components, separated by "/".
/// E.g. `foo/bar/baz`
///
/// ## Invariants
///
/// A valid path must meet the following criteria:
///
/// * It cannot be empty.
/// * It cannot be longer than [`MAX_PATH_LENGTH`].
/// * It cannot have a leading "/".
/// * It cannot have a trailing "/".
/// * It must be exactly "." OR each of its components must be a valid [`Name`].
///
/// Paths should be transformed into their canonical forms at client side.
/// For example, a client should convert `"foo/bar/.././baz/"` to `"foo/baz"`
/// before using it as a path.
pub type Path = String;

/// Rights are properties specific to a connection. They limit which operations are allowed on a
/// connection, including those which may be granted to new connections.
///
/// Invoking an operation without the corresponding right results in `ZX_ERR_ACCESS_DENIED`
/// even if the node does not have support for the operation.
pub type Rights = Operations;

pub type SymlinkTarget = Vec<u8>;

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

/// The byte vector type used for read/write operations.
pub type Transfer = Vec<u8>;

pub const DIRECTORY_PROTOCOL_NAME: &str = "fuchsia.io/Directory";

pub const FILE_PROTOCOL_NAME: &str = "fuchsia.io/File";

/// Set of rights that [`Flags.PERM_INHERIT_WRITE`] will inherit from the parent connection if
/// specified. Note that if any of these permissions are missing from the connection, none of these
/// permissions will be inherited.
pub const INHERITED_WRITE_PERMISSIONS: Operations = Operations::from_bits_truncate(356);

/// Nodes which do not have ino values should return this value
/// from Readdir and GetAttr.
pub const INO_UNKNOWN: u64 = 18446744073709551615;

pub const MASK_KNOWN_PERMISSIONS: Flags = Flags::from_bits_truncate(25087);

pub const MASK_KNOWN_PROTOCOLS: Flags = Flags::from_bits_truncate(30069489664);

pub const MASK_PERMISSION_FLAGS: u64 = 65535;

pub const MASK_POSIX_FLAGS: u64 = 4294967295;

/// The maximum size for an extended attribute name.
pub const MAX_ATTRIBUTE_NAME: u64 = 255;

/// The maximal buffer size which can be transmitted for buffered operations.
/// This capacity is currently set somewhat arbitrarily.
pub const MAX_BUF: u64 = 8192;

/// The maximum length, in bytes, of a single filesystem component.
pub const MAX_FILENAME: u64 = 255;

pub const MAX_FS_NAME_BUFFER: u64 = 32;

/// The maximum size for an extended attribute value to be included inline.
/// Values larger than this size are passed in a vmo.
pub const MAX_INLINE_ATTRIBUTE_VALUE: u64 = 32768;

/// The maximum size of a chunk in the ListExtendedAttributes iterator.
pub const MAX_LIST_ATTRIBUTES_CHUNK: u64 = 128;

/// The maximum length, in bytes, of a single filesystem component.
pub const MAX_NAME_LENGTH: u64 = 255;

/// The maximum length, in bytes, of a filesystem path.
pub const MAX_PATH_LENGTH: u64 = 4095;

/// The maximum size for passing the SELinux context as an attribute.
pub const MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN: u64 = 256;

/// The maximum I/O size that is allowed for read/write operations using
/// byte vectors.
pub const MAX_TRANSFER_SIZE: u64 = 8192;

/// Bits reserved for posix protections. Native fuchsia filesystems
/// are not required to set bits contained within `MODE_PROTECTION_MASK`,
/// but filesystems that wish to do so may refer to sys/stat.h for their
/// definitions.
pub const MODE_PROTECTION_MASK: u32 = 4095;

pub const MODE_TYPE_BLOCK_DEVICE: u32 = 24576;

pub const MODE_TYPE_DIRECTORY: u32 = 16384;

pub const MODE_TYPE_FILE: u32 = 32768;

/// Bits indicating node type. The canonical mechanism to check
/// for a node type is to take 'mode', bitwise AND it with the
/// `MODE_TYPE_MASK`, and check exact equality against a mode type.
pub const MODE_TYPE_MASK: u32 = 1044480;

pub const MODE_TYPE_SERVICE: u32 = 65536;

pub const MODE_TYPE_SYMLINK: u32 = 40960;

pub const NODE_PROTOCOL_NAME: &str = "fuchsia.io/Node";

/// Flags used when opening a node reference must fall within this mask.
pub const OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE: OpenFlags =
    OpenFlags::from_bits_truncate(46661632);

/// All known rights.
pub const OPEN_RIGHTS: OpenFlags = OpenFlags::from_bits_truncate(11);

/// Set of permissions that are expected when opening a node as executable.
pub const PERM_EXECUTABLE: Flags = Flags::from_bits_truncate(201);

/// Set of permissions that are expected when opening a node as readable.
pub const PERM_READABLE: Flags = Flags::from_bits_truncate(211);

/// Set of permissions that are expected when opening a node as writable.
pub const PERM_WRITABLE: Flags = Flags::from_bits_truncate(485);

/// Alias for directory permission alias rw*
pub const RW_STAR_DIR: Operations = Operations::from_bits_truncate(503);

/// Alias for directory permission alias rx*
pub const RX_STAR_DIR: Operations = Operations::from_bits_truncate(219);

/// Alias for directory permission alias r*
pub const R_STAR_DIR: Operations = Operations::from_bits_truncate(211);

/// The name of the extended attribute accessible via the SELinux context attribute.
pub const SELINUX_CONTEXT_NAME: &str = "security.selinux";

pub const SYMLINK_PROTOCOL_NAME: &str = "fuchsia.io/Symlink";

/// Alias for directory permission alias w*
pub const W_STAR_DIR: Operations = Operations::from_bits_truncate(485);

/// Alias for directory permission alias x*
pub const X_STAR_DIR: Operations = Operations::from_bits_truncate(201);

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct AllocateMode: u32 {
        const KEEP_SIZE = 1;
        const UNSHARE_RANGE = 2;
        const PUNCH_HOLE = 4;
        const COLLAPSE_RANGE = 8;
        const ZERO_RANGE = 16;
        const INSERT_RANGE = 32;
    }
}

impl AllocateMode {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u32) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConnectorFlags: u64 {
    }
}

impl ConnectorFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct FileProtocolFlags: u64 {
        /// Opens the file in append mode, i.e. the connection should seek to the end of the
        /// file before every write.
        ///
        /// If the file does not support appending, it should result in a `ZX_ERR_NOT_SUPPORTED`
        /// epitaph. Currently, only [`NodeProtocolKinds.FILE`] connections support appending.
        const APPEND = 1;
        /// Truncates the object before usage, by setting its length to 0. Requires the
        /// [`Rights.WRITE_BYTES`] right on the connection.
        ///
        /// If the file does not support truncating, it should result in a
        /// `ZX_ERR_NOT_SUPPORTED` epitaph.
        const TRUNCATE = 2;
    }
}

impl FileProtocolFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct FileSignal: u32 {
        /// Indicates the file is ready for reading.
        const READABLE = 16777216;
        /// Indicates the file is ready for writing.
        const WRITABLE = 33554432;
    }
}

impl FileSignal {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

bitflags! {
    /// Flags used to specify how a node should be opened. Note that ranges of bits are reserved
    /// for specific use cases:
    ///  * Bits  1-16: Permission flags `PERM_*` (e.g. [`Flags.PERM_READ`]).
    ///  * Bits 17-32: POSIX compatibile `O_*` flags (e.g. [`Flags.FILE_TRUNCATE`] or `O_TRUNC`).
    ///  * Bits 33-64: Fuchsia-specific flags.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Flags: u64 {
        /// Allows opening child nodes with [`PROTOCOL_SERVICE`].
        const PERM_CONNECT = 1;
        /// Read byte contents of a file.
        const PERM_READ = 2;
        /// Write byte contents to a file.
        const PERM_WRITE = 4;
        /// Execute byte contents of a file.
        const PERM_EXECUTE = 8;
        /// Get/query attributes of a node.
        const PERM_GET_ATTRIBUTES = 16;
        /// Set/update attributes of a node.
        const PERM_SET_ATTRIBUTES = 32;
        /// Enumerate (list) directory entries.
        const PERM_ENUMERATE = 64;
        /// Allow opening a child node with a node protocol. Must be specified with PERM_ENUMERATE
        /// otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.
        const PERM_TRAVERSE = 128;
        /// Modify directory entries (create/rename/link/unlink). Must be specified with PERM_ENUMERATE
        /// otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.
        const PERM_MODIFY = 256;
        /// Inherit write permissions when available (PERM_WRITE, PERM_SET_ATTRIBUTES, PERM_MODIFY,
        /// PERM_ENUMERATE). Servers must ensure this flag is removed if the parent connection lacks any
        /// of these rights. See [`INHERITED_WRITE_PERMISSIONS`] for the exact set of permissions that
        /// will be inherited.
        const PERM_INHERIT_WRITE = 8192;
        /// Inherit execute permission when available (PERM_EXECUTE).
        /// Servers must ensure this flag is removed if the parent connection lacks PERM_EXECUTE.
        const PERM_INHERIT_EXECUTE = 16384;
        /// Connect to the underlying protocol if this is a service node. The caller must determine the
        /// correct protocol to use (e.g. based on path). Unless used with [`PROTOCOL_NODE`], specifying
        /// other flags with the request will fail with `ZX_ERR_INVALID_ARGS`.
        const PROTOCOL_SERVICE = 4294967296;
        /// Connect to the underlying node. Takes precedence over other protocols. If other `PROTOCOL_*`
        /// are specified, they will be used to validate the target node type. Requests will fail with
        /// `ZX_ERR_INVALID_ARGS` if flags other than `PROTOCOL_*` and [`FLAG_SEND_REPRESENTATION`] are
        /// specified. Equivalent to POSIX `O_PATH`.
        const PROTOCOL_NODE = 4194304;
        /// Caller accepts [`fuchsia.io/Directory`] protocol. Equivalent to POSIX `O_DIRECTORY`.
        const PROTOCOL_DIRECTORY = 524288;
        /// Caller accepts [`fuchsia.io/File`] protocol.
        const PROTOCOL_FILE = 8589934592;
        /// Caller accepts [`fuchsia.io/Symlink`] protocol.
        const PROTOCOL_SYMLINK = 17179869184;
        /// Caller requests a [`fuchsia.io/Node.OnRepresentation`] event on success.
        const FLAG_SEND_REPRESENTATION = 1099511627776;
        /// Create a new object if one doesn't exist, otherwise open an existing object. If set, a
        /// single `PROTOCOL_*` flag must be set indicating the type of object to create. Equivalent
        /// to POSIX `O_CREAT`.
        const FLAG_MAYBE_CREATE = 65536;
        /// Create a new object if one doesn't exist, otherwise fail the request with
        /// `ZX_ERR_ALREADY_EXISTS`. If set, a single `PROTOCOL_*` flag must be set indicating the type
        /// of object to create. Takes precedence over [`FLAG_CREATE`]. Equivalent to POSIX `O_EXCL`.
        const FLAG_MUST_CREATE = 131072;
        /// Open the file in append mode. The seek pointer will be moved to end-of-file (EOF)
        /// before all writes. Equivalent to POSIX `O_APPEND`.
        const FILE_APPEND = 1048576;
        /// Truncate the file to zero length upon opening it. Equivalent to POSIX `O_TRUNC`.
        const FILE_TRUNCATE = 262144;
    }
}

impl Flags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ModeType: u32 {
        const DO_NOT_USE = 2147483648;
    }
}

impl ModeType {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

bitflags! {
    /// The fields of 'attributes' which are used to update the Node are indicated
    /// by the 'flags' argument.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeAttributeFlags: u32 {
        const CREATION_TIME = 1;
        const MODIFICATION_TIME = 2;
    }
}

impl NodeAttributeFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeAttributesQuery: u64 {
        /// Requests [`NodeAttributes.protocols`].
        const PROTOCOLS = 1;
        /// Requests [`NodeAttributes.abilities`].
        const ABILITIES = 2;
        /// Requests [`NodeAttributes.content_size`].
        const CONTENT_SIZE = 4;
        /// Requests [`NodeAttributes.storage_size`].
        const STORAGE_SIZE = 8;
        /// Requests [`NodeAttributes.link_count`].
        const LINK_COUNT = 16;
        /// Requests [`NodeAttributes.id`].
        const ID = 32;
        /// Requests [`NodeAttributes.creation_time`].
        const CREATION_TIME = 64;
        /// Requests [`NodeAttributes.modification_time`].
        const MODIFICATION_TIME = 128;
        /// Posix attributes.
        const MODE = 256;
        const UID = 512;
        const GID = 1024;
        const RDEV = 2048;
        const ACCESS_TIME = 4096;
        const CHANGE_TIME = 8192;
        /// Verity attributes.
        const OPTIONS = 16384;
        const ROOT_HASH = 32768;
        const VERITY_ENABLED = 65536;
        /// Casefold (case-insensitive filename) support.
        /// When true, file lookups will be case-insensitive but case-preserving. i.e. "Foo" will
        /// be stored verbatim but can be opened as "foo", "fOO", etc. Casefolding is done in
        /// accordance to the Unicode 12 NFD normalization and casefolding standard.
        const CASEFOLD = 131072;
        /// Requests [`MutableNodeAttributes.selinux_context`]. See that field for more detail.
        const SELINUX_CONTEXT = 262144;
        /// fscrypt attribute.
        const WRAPPING_KEY_ID = 524288;
    }
}

impl NodeAttributesQuery {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeFlags: u64 {
        /// Requests that an [`Node.OnRepresentation`] event be sent as the first message on the
        /// protocol request.
        ///
        /// This is a special case of [`fuchsia.unknown/Queryable.Query`] + inherent `Describe`
        /// methods on the specific protocols. It exists as an optimization to avoid an additional
        /// round trip.
        const GET_REPRESENTATION = 1;
    }
}

impl NodeFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeProtocolFlags: u64 {
        /// Only allow the connection if the underlying object is a directory. An attempt to
        /// open something other than a directory will result in a `ZX_ERR_NOT_DIR` epitaph.
        const MUST_BE_DIRECTORY = 1;
    }
}

impl NodeProtocolFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    /// A node may have multiple supported representations when opening, even though
    /// it may have a fixed underlying identity.
    ///
    /// Today, a file is accessed via the [`File`] protocol, and sends a
    /// [`Representation.FileInfo`] when opened with `GET_REPRESENTATION`. However,
    /// in the future we might introduce a more sophisticated `FileV2` protocol, or
    /// a more efficient `SuperFastFile` backed by a specialized kernel object. New
    /// clients can request the more advanced representations by specifying the
    /// corresponding bits in [`NodeProtocolKinds`], whereas existing clients would
    /// continue to talk to the node via the old representation.
    ///
    /// [`NodeProtocolKinds`] enables forward-compatibility through a form of protocol
    /// negotiation.
    ///
    /// The elements have one-to-one correspondence with the members of
    /// [`Representation`].
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeProtocolKinds: u64 {
        /// The connector representation of a node.
        ///
        /// The connection will speak either [`Node`] or the target protocol,
        /// depending on the flags used during opening.
        const CONNECTOR = 1;
        /// The directory representation of a node.
        ///
        /// The connection will speak the [`Directory`] protocol.
        const DIRECTORY = 2;
        /// The file representation of a node.
        ///
        /// The connection will speak the [`File`] protocol.
        const FILE = 4;
        /// The symlink representation of a node.
        ///
        /// The connection will speak the [`Symlink`] protocol.
        const SYMLINK = 8;
    }
}

impl NodeProtocolKinds {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    /// DEPRECATED - Use Flags instead.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OpenFlags: u32 {
        /// Can read from target object.
        const RIGHT_READABLE = 1;
        /// Can write to target object.
        const RIGHT_WRITABLE = 2;
        /// Connection can map target object executable.
        const RIGHT_EXECUTABLE = 8;
        /// Create the object if it doesn't exist.
        const CREATE = 65536;
        /// (with Create) Fail if the object already exists.
        const CREATE_IF_ABSENT = 131072;
        /// Truncate the object before usage.
        const TRUNCATE = 262144;
        /// Assert that the object to be opened is a directory.
        /// Return an error if the target object is not a directory.
        const DIRECTORY = 524288;
        /// Seek to the end of the object before all writes.
        const APPEND = 1048576;
        /// Open a reference to the object, not the object itself.
        /// It is ONLY valid to pass the following flags together with `NODE_REFERENCE`:
        /// - `DIRECTORY`
        /// - `NOT_DIRECTORY`
        /// - `DESCRIBE`
        /// otherwise an error is returned.
        /// If an object is opened or cloned using this method, the resulting connection does not carry
        /// any permission flags.
        /// The resulting connection allows a limited set of operations: `GetAttr`, `Clone`, `Close`,
        /// `Describe`, and `GetFlags`. The connection will speak the `Node` protocol. Calling `SetAttr`
        /// or `SetFlags` will result in `ZX_ERR_BAD_HANDLE`.
        const NODE_REFERENCE = 4194304;
        /// Requests that an "OnOpen" event is sent to the interface request.
        ///
        /// The event will contain a non-null `NodeInfoDeprecated` if the open/clone is successful. This
        /// can be used to open a protocol that does not compose fuchsia.io/Node; the event is sent as
        /// if the protocol is fuchsia.io/Node and then the target protocol is used exclusively.
        const DESCRIBE = 8388608;
        /// Specify this flag to request POSIX-compatibility with respect to write permission handling.
        /// Currently, it affects permission handling specifically during Open:
        /// - If the target path is a directory, the rights on the new connection expand to include
        ///   `WRITABLE` if and only if the current connection and all intermediate mount points
        ///   are writable.
        /// - Otherwise, this flag is ignored. It is an access denied error to request more rights
        ///   than those on the current connection, or any intermediate mount points.
        ///
        /// If this flag is omitted, opening always uses the requested rights, failing the operation with
        /// access denied error if requested rights exceeds the rights attached to the current connection.
        ///
        /// If the requesting connection is read-only and the requested rights are read-only, the flag
        /// may be ignored by the server, and is not forwarded downstream. This is an implementation detail,
        /// necessary to enforce hierarchical permissions across mount points, and should have no effect
        /// on the expected behavior for clients.
        const POSIX_WRITABLE = 134217728;
        /// Specify this flag to request POSIX-compatibility with respect to execute permission handling.
        /// Currently, it affects permission handling specifically during Open:
        /// - If the target path is a directory, the rights on the new connection expand to include
        ///   `EXECUTABLE` if and only if the current connection and all intermediate mount
        ///   points are executable.
        /// - Otherwise, this flag is ignored. It is an access denied error to request more rights
        ///   than those on the current connection, or any intermediate mount points.
        ///
        /// If this flag is omitted, opening always uses the requested rights, failing the operation with
        /// access denied error if requested rights exceeds the rights attached to the current connection.
        ///
        /// If the requesting connection is read-only and the requested rights are read-only, the flag
        /// may be ignored by the server, and is not forwarded downstream. This is an implementation detail,
        /// necessary to enforce hierarchical permissions across mount points, and should have no effect
        /// on the expected behavior for clients.
        const POSIX_EXECUTABLE = 268435456;
        /// Assert that the object to be opened is not a directory.
        /// Return an error if the target object is a directory.
        const NOT_DIRECTORY = 33554432;
        /// When used during clone, the new connection inherits the rights on the source connection,
        /// regardless if it is a file or directory. Otherwise, clone attempts to use the requested rights.
        /// It is invalid to pass any of the `RIGHT_*` flags together with `OpenFlags.CLONE_SAME_RIGHTS`.
        const CLONE_SAME_RIGHTS = 67108864;
        /// Open the target object as a block device.
        const BLOCK_DEVICE = 16777216;
    }
}

impl OpenFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

bitflags! {
    /// The common members definition behind [`Rights`] and [`Abilities`]. Some operations may apply
    /// only to certain node types (e.g. [`Operations.MODIFY_DIRECTORY`] only applies to directories).
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Operations: u64 {
        /// Connecting to a service in a directory.
        const CONNECT = 1;
        /// Read byte contents of a node or its children.
        const READ_BYTES = 2;
        /// Writing to the byte contents of a node or its children.
        const WRITE_BYTES = 4;
        /// Execute the byte contents of a node or its children.
        const EXECUTE = 8;
        /// Reading the attributes of a node and/or its children.
        const GET_ATTRIBUTES = 16;
        /// Updating the attributes of a node and/or its children.
        const UPDATE_ATTRIBUTES = 32;
        /// Reading the list of nodes in a directory.
        const ENUMERATE = 64;
        /// Opening a node from a directory. Must be specified with [`Rights.ENUMERATE`], as directory
        /// contents can be probed by opening children.
        const TRAVERSE = 128;
        /// Modifying the list of nodes in a directory, e.g. creating, renaming, link/unlink, etc...
        /// Must be specified with [`Rights.ENUMERATE`], as directory contents can be probed via name
        /// conflicts during node creation.
        const MODIFY_DIRECTORY = 256;
    }
}

impl Operations {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        0
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SymlinkProtocolFlags: u64 {
    }
}

impl SymlinkProtocolFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UnlinkFlags: u64 {
        /// If set, the unlink will fail (with ZX_ERR_NOT_DIR) if the
        /// object is not a directory.
        const MUST_BE_DIRECTORY = 1;
    }
}

impl UnlinkFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits() & !Self::all().bits()
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct VmoFlags: u32 {
        /// Requests that the VMO be readable.
        const READ = 1;
        /// Requests that the VMO be writable.
        const WRITE = 2;
        /// Request that the VMO be executable.
        const EXECUTE = 4;
        /// Require a copy-on-write clone of the underlying VMO. The request
        /// should fail if the VMO cannot be cloned. May not be supplied
        /// with `SHARED_BUFFER`.
        ///
        /// A private clone uses at least the guarantees of the
        /// `ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE` flag to
        /// `zx_vmo_create_child()`. This means that the returned VMO will
        /// be copy-on-write (if `WRITE` is requested) but that it may or
        /// may not reflect subsequent content changes to the underlying
        /// file. The returned VMO will not reflect size changes to the
        /// file. These semantics match those of the POSIX `mmap()`
        /// `MAP_PRIVATE` flag.
        ///
        /// In some cases, clients requiring a guaranteed snapshot of the
        /// file can use `SHARED_BUFFER` and then use
        /// `zx_vmo_create_child()` with `ZX_VMO_CHILD_SNAPSHOT`. However,
        /// in addition to cases where the implementation can't return a
        /// `SHARED_BUFFER`, creating a full snapshot will fail if the VMO
        /// is attached to the pager. Since most filesystems will use the
        /// paging system, the full snapshot approach should only be used in
        /// specific cases where the client is talking to a known server.
        const PRIVATE_CLONE = 65536;
        /// Require a VMO that provides direct access to the contents of the
        /// file's underlying VMO. The request should fail if such a VMO
        /// cannot be provided. May not be supplied with `PRIVATE_CLONE`.
        ///
        /// The returned VMO may not be resizable even when `WRITE` access is
        /// requested. In this case, [`File.Resize`] should be used to resize
        /// the file.
        const SHARED_BUFFER = 131072;
    }
}

impl VmoFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

bitflags! {
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct WatchMask: u32 {
        /// Used by `Directory.Watch`. Requests transmission of `WatchEvent.DELETED`.
        const DELETED = 1;
        /// Used by `Directory.Watch`. Requests transmission of `WatchEvent.ADDED`.
        const ADDED = 2;
        /// Used by `Directory.Watch`. Requests transmission of `WatchEvent.REMOVED`.
        const REMOVED = 4;
        /// Used by `Directory.Watch`. Requests transmission of `WatchEvent.EXISTING`.
        const EXISTING = 8;
        /// Used by `Directory.Watch`. Requests transmission of `WatchEvent.IDLE`.
        const IDLE = 16;
    }
}

impl WatchMask {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum AdvisoryLockType {
    /// Zero or more connections can hold read locks on a file simultaneously.
    Read = 1,
    /// At most one connection can hold a write lock on a file simultaneously.
    /// When a write lock is held on a file, no other types of locks can be held
    /// on that file.
    Write = 2,
    /// The region specifies a region to be unlocked.
    Unlock = 3,
}

impl AdvisoryLockType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Read),
            2 => Some(Self::Write),
            3 => Some(Self::Unlock),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum CreationMode {
    /// Only open an existing object, never create a new object.
    Never = 0,
    NeverDeprecated = 1,
    /// Create a new object if one does not exist, otherwise open the existing object.
    AllowExisting = 2,
    /// Create a new object if one does not exist, otherwise the request will fail with
    /// `ZX_ERR_ALREADY_EXISTS`.
    Always = 3,
}

impl CreationMode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Never),
            1 => Some(Self::NeverDeprecated),
            2 => Some(Self::AllowExisting),
            3 => Some(Self::Always),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum DirentType {
    /// A dirent with an unknown type.
    Unknown,
    /// A dirent representing a directory object.
    Directory,
    /// A dirent representing a block device object.
    BlockDevice,
    /// A dirent representing a file object.
    File,
    /// A symbolic link.
    Symlink,
    /// A dirent representing a service object.
    Service,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u8 },
}

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

impl DirentType {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::Unknown),
            4 => Some(Self::Directory),
            6 => Some(Self::BlockDevice),
            8 => Some(Self::File),
            10 => Some(Self::Symlink),
            16 => Some(Self::Service),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            0 => Self::Unknown,
            4 => Self::Directory,
            6 => Self::BlockDevice,
            8 => Self::File,
            10 => Self::Symlink,
            16 => Self::Service,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Unknown => 0,
            Self::Directory => 4,
            Self::BlockDevice => 6,
            Self::File => 8,
            Self::Symlink => 10,
            Self::Service => 16,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Denotes which hash algorithm is used to build the merkle tree for
/// fsverity-enabled files.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum HashAlgorithm {
    Sha256,
    Sha512,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u8,
    },
}

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

impl HashAlgorithm {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Sha256),
            2 => Some(Self::Sha512),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            1 => Self::Sha256,
            2 => Self::Sha512,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Sha256 => 1,
            Self::Sha512 => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// The reference point for updating the seek offset. See [`File.Seek`].
///
/// This enum matches the `zx_stream_seek_origin_t` enum.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum SeekOrigin {
    /// Seek from the start of the file.
    /// The seek offset will be set to `offset` bytes.
    /// The seek offset cannot be negative in this case.
    Start = 0,
    /// Seek from the current position in the file.
    /// The seek offset will be the current seek offset plus `offset` bytes.
    Current = 1,
    /// Seek from the end of the file.
    /// The seek offset will be the file size plus `offset` bytes.
    End = 2,
}

impl SeekOrigin {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Start),
            1 => Some(Self::Current),
            2 => Some(Self::End),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum SetExtendedAttributeMode {
    /// Set the value of the extended attribute regardless of whether it
    /// already exists.
    Set = 1,
    /// Create a new extended attribute. Fail if it already exists.
    Create = 2,
    /// Replace the value of an existing extended attribute. Fail if it
    /// doesn't already exist.
    Replace = 3,
}

impl SetExtendedAttributeMode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Set),
            2 => Some(Self::Create),
            3 => Some(Self::Replace),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum WatchEvent {
    /// Indicates the directory being watched has been deleted. The name returned for this event
    /// will be `.` (dot), as it is refering to the directory itself.
    Deleted = 0,
    /// Indicates a node has been created (either new or moved) into a directory.
    Added = 1,
    /// Identifies a node has been removed (either deleted or moved) from the directory.
    Removed = 2,
    /// Identifies a node already existed in the directory when watching started.
    Existing = 3,
    /// Identifies that no more `EXISTING` events will be sent. The name returned for this event
    /// will be empty, as it is not refering to a specific entry.
    Idle = 4,
}

impl WatchEvent {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::Deleted),
            1 => Some(Self::Added),
            2 => Some(Self::Removed),
            3 => Some(Self::Existing),
            4 => Some(Self::Idle),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AdvisoryLockRange {
    /// The location in the file from which [`offset`] is computed.
    pub origin: SeekOrigin,
    /// The start of the byte range, expressed as an offset from [`origin`].
    /// Cannot be negative if [`origin`] is [`SeekOrigin.START`].
    pub offset: i64,
    /// The length of the byte range in bytes.
    ///
    /// If the length is zero, then the byte range extends until the end of the
    /// file, regardless of how large the file becomes.
    ///
    /// If the length is negative, the byte range includes the bytes `offset` +
    /// `length` up to, and including, `offset` - 1, provided this range does
    /// not extend beyond the beginning of the file.
    pub length: i64,
}

impl fidl::Persistable for AdvisoryLockRange {}

#[derive(Clone, Debug, PartialEq)]
pub struct AdvisoryLockingAdvisoryLockRequest {
    pub request: AdvisoryLockRequest,
}

impl fidl::Persistable for AdvisoryLockingAdvisoryLockRequest {}

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

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

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

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

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DirectoryLinkResponse {
    pub s: i32,
}

impl fidl::Persistable for DirectoryLinkResponse {}

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

impl fidl::Persistable for DirectoryObject {}

#[derive(Debug, PartialEq)]
pub struct DirectoryOpen2Request {
    /// Identifies the node to open.
    ///
    /// If it contains multiple segments, then the directory is traversed one segment at a time,
    /// relative to the directory represented by this connection.
    pub path: String,
    /// The representations accepted by the caller to support a form of protocol negotiation on
    /// the node being opened.
    pub protocols: ConnectionProtocols,
    /// The server end of a channel created for the new connection. The caller may proceed to
    /// send messages on the corresponding client end right away.
    pub object_request: fidl::Channel,
}

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

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

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

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DirectoryReadDirentsRequest {
    pub max_bytes: u64,
}

impl fidl::Persistable for DirectoryReadDirentsRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DirectoryReadDirentsResponse {
    pub s: i32,
    pub dirents: Vec<u8>,
}

impl fidl::Persistable for DirectoryReadDirentsResponse {}

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DirectoryRewindResponse {
    pub s: i32,
}

impl fidl::Persistable for DirectoryRewindResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct DirectoryUnlinkRequest {
    pub name: String,
    pub options: UnlinkOptions,
}

impl fidl::Persistable for DirectoryUnlinkRequest {}

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DirectoryWatchResponse {
    pub s: i32,
}

impl fidl::Persistable for DirectoryWatchResponse {}

/// Used in places where empty structs are needed, such as empty union members, to avoid creating
/// new struct types.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EmptyStruct;

impl fidl::Persistable for EmptyStruct {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ExtendedAttributeIteratorGetNextResponse {
    pub attributes: Vec<Vec<u8>>,
    pub last: bool,
}

impl fidl::Persistable for ExtendedAttributeIteratorGetNextResponse {}

#[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<fidl::encoding::DefaultFuchsiaResourceDialect> for FileAllocateRequest {}

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileGetBackingMemoryRequest {
    pub flags: VmoFlags,
}

impl fidl::Persistable for FileGetBackingMemoryRequest {}

#[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<fidl::Event>,
    /// A placeholder for future stream support.
    ///
    /// Currently, servers are required not to send a handle in this field.
    pub stream: Option<fidl::Stream>,
}

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FileReadAtRequest {
    pub count: u64,
    pub offset: u64,
}

impl fidl::Persistable for FileReadAtRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FileResizeRequest {
    pub length: u64,
}

impl fidl::Persistable for FileResizeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileSeekRequest {
    pub origin: SeekOrigin,
    pub offset: i64,
}

impl fidl::Persistable for FileSeekRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileWriteAtRequest {
    pub data: Vec<u8>,
    pub offset: u64,
}

impl fidl::Persistable for FileWriteAtRequest {}

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

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileReadAtResponse {
    pub data: Vec<u8>,
}

impl fidl::Persistable for FileReadAtResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FileSeekResponse {
    pub offset_from_start: u64,
}

impl fidl::Persistable for FileSeekResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FileWriteAtResponse {
    pub actual_count: u64,
}

impl fidl::Persistable for FileWriteAtResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FilesystemInfo {
    /// The number of data bytes which may be stored in a filesystem. This does not count
    /// metadata or other filesystem overhead like block rounding.
    pub total_bytes: u64,
    /// The number of data bytes which are in use by the filesystem. This does not count
    /// metadata or other filesystem overhead like block rounding.
    pub used_bytes: u64,
    /// The number of nodes which may be stored in the filesystem.
    pub total_nodes: u64,
    /// The number of nodes used by the filesystem.
    pub used_nodes: u64,
    /// The amount of additional space which may be allocated from the underlying volume
    /// manager. If unsupported or there is no space for the filesystem to grow, this will
    /// be zero.
    pub free_shared_pool_bytes: u64,
    /// A unique identifier for this filesystem instance. Will not be preserved across
    /// reboots.
    ///
    /// Implementors should create a kernel object (normally an event) and use its koid for
    /// the filesystem ID. This koid guarantees uniqueness in the system.
    pub fs_id: u64,
    /// The size in bytes of a single filesystem block.
    pub block_size: u32,
    /// The maximum length of a filesystem name.
    pub max_filename_size: u32,
    /// A unique identifier for the type of the underlying filesystem.
    pub fs_type: u32,
    pub padding: u32,
    pub name: [i8; 32],
}

impl fidl::Persistable for FilesystemInfo {}

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

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

/// NodeAttributes defines generic information about a filesystem node.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NodeAttributes {
    /// Protection bits and node type information describe in 'mode'.
    pub mode: u32,
    /// A filesystem-unique ID.
    pub id: u64,
    /// Node size, in bytes.
    pub content_size: u64,
    /// Space needed to store node (possibly larger than size), in bytes.
    pub storage_size: u64,
    /// Hard link count.
    pub link_count: u64,
    /// Time of creation (may be updated manually after creation) in ns since Unix epoch, UTC.
    pub creation_time: u64,
    /// Time of last modification in ns since Unix epoch, UTC.
    pub modification_time: u64,
}

impl fidl::Persistable for NodeAttributes {}

#[derive(Clone, Debug, PartialEq)]
pub struct NodeAttributes2 {
    pub mutable_attributes: MutableNodeAttributes,
    pub immutable_attributes: ImmutableNodeAttributes,
}

impl fidl::Persistable for NodeAttributes2 {}

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NodeGetAttrResponse {
    pub s: i32,
    pub attributes: NodeAttributes,
}

impl fidl::Persistable for NodeGetAttrResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeGetAttributesRequest {
    /// Set the corresponding bit to one to query that particular attribute.
    ///
    /// The elements here correspond one-to-one with [`NodeAttributes`].
    pub query: NodeAttributesQuery,
}

impl fidl::Persistable for NodeGetAttributesRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeGetExtendedAttributeRequest {
    pub name: Vec<u8>,
}

impl fidl::Persistable for NodeGetExtendedAttributeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeGetFlagsResponse {
    pub s: i32,
    pub flags: OpenFlags,
}

impl fidl::Persistable for NodeGetFlagsResponse {}

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

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

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

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

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

impl fidl::Persistable for NodeQueryFilesystemResponse {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeRemoveExtendedAttributeRequest {
    pub name: Vec<u8>,
}

impl fidl::Persistable for NodeRemoveExtendedAttributeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeSetAttrRequest {
    pub flags: NodeAttributeFlags,
    pub attributes: NodeAttributes,
}

impl fidl::Persistable for NodeSetAttrRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NodeSetAttrResponse {
    pub s: i32,
}

impl fidl::Persistable for NodeSetAttrResponse {}

#[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<fidl::encoding::DefaultFuchsiaResourceDialect>
    for NodeSetExtendedAttributeRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NodeSetFlagsRequest {
    pub flags: OpenFlags,
}

impl fidl::Persistable for NodeSetFlagsRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NodeSetFlagsResponse {
    pub s: i32,
}

impl fidl::Persistable for NodeSetFlagsResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ReadableReadRequest {
    pub count: u64,
}

impl fidl::Persistable for ReadableReadRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ReadableReadResponse {
    pub data: Vec<u8>,
}

impl fidl::Persistable for ReadableReadResponse {}

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

impl fidl::Persistable for Service {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SymlinkObject {
    pub target: Vec<u8>,
}

impl fidl::Persistable for SymlinkObject {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WritableWriteRequest {
    pub data: Vec<u8>,
}

impl fidl::Persistable for WritableWriteRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct WritableWriteResponse {
    pub actual_count: u64,
}

impl fidl::Persistable for WritableWriteResponse {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct AdvisoryLockRequest {
    /// The type of lock to be acquired.
    ///
    /// If this field is absent, the [`AdvisoryLock`] method will fail
    /// with ZX_ERR_INVALID_ARGS.
    pub type_: Option<AdvisoryLockType>,
    /// The byte range within the file to be locked.
    ///
    /// The range can extend beyond the end of the file but cannot extend beyond
    /// the beginning of the file.
    ///
    /// If this field is absent, the range defaults to the entire file.
    pub range: Option<AdvisoryLockRange>,
    /// Whether the file should wait reply to the [`AdvisoryLock`]
    /// method until the requested lock can be acquired.
    ///
    /// If this field is absent, the file will not wait.
    pub wait: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for AdvisoryLockRequest {}

#[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<fidl::encoding::DefaultFuchsiaResourceDialect> for ConnectionInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct ConnectorInfo {
    /// Requested attributes for the object. This is only populated if requested.
    pub attributes: Option<NodeAttributes2>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ConnectorInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct DirectoryInfo {
    /// Requested attributes for the directory. This is only populated if requested.
    pub attributes: Option<NodeAttributes2>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for DirectoryInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct DirectoryProtocolOptions {
    /// Optional rights to be negotiated.
    ///
    /// When present, indicates that the caller requests additional optional rights equal to
    /// the intersection of this value and the rights on the requesting connection. This
    /// acts as a high water mark that prevents rights escalation as this request is proxied
    /// over multiple hops; each proxy must intersect the value with the rights on the
    /// requesting connection before proxying on.
    ///
    /// This field is necessary to express POSIX semantics where `open` of a directory must
    /// be `O_RDONLY` yet `openat` can be used to open non-directory nodes within that
    /// directory with privileges exceeding `O_RDONLY`. This means that POSIX clients must
    /// always set this to the full set of [`Rights`] to implement `open` or `openat` calls
    /// which don't forbid directories (e.g. `O_WRONLY` and `O_RDWR` do forbid directories).
    pub optional_rights: Option<Operations>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for DirectoryProtocolOptions {}

/// 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<fidl::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<fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect> for FileInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct ImmutableNodeAttributes {
    /// Describes the kinds of representations supported by the node.
    /// Note: This is not the result of the connection-time negotiation,
    /// which is conveyed via `representation`.
    pub protocols: Option<NodeProtocolKinds>,
    /// Describes the kinds of operations supported by the node.
    /// Note: This is distinct from the rights used at connection time.
    pub abilities: Option<Operations>,
    /// Node size, in bytes.
    pub content_size: Option<u64>,
    /// Space needed to store the node (possibly larger than size), in bytes.
    pub storage_size: Option<u64>,
    /// Number of hard links to the node. It must be at least one.
    pub link_count: Option<u64>,
    /// An ID for the node. See [`Id`].
    /// This `id` should be unique among all entries of a directory.
    pub id: Option<u64>,
    /// Time of last change to the metadata in nanoseconds since the Unix epoch, UTC.
    pub change_time: Option<u64>,
    /// Contains the verification options for verity-enabled files.
    pub options: Option<VerificationOptions>,
    /// The root hash for the file. Not all filesystems support this across all files.
    pub root_hash: Option<Vec<u8>>,
    /// True if this file is verity-enabled.
    pub verity_enabled: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ImmutableNodeAttributes {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct MutableNodeAttributes {
    /// Time of creation in nanoseconds since the Unix epoch, UTC.
    pub creation_time: Option<u64>,
    /// Time of last modification in nanoseconds since the Unix epoch, UTC.
    pub modification_time: Option<u64>,
    /// POSIX compatibility attributes. Most filesystems will not support
    /// these. Those that do must simply store and retrieve them (e.g. as
    /// extended attributes) and not attempt to interpret them (e.g. by doing
    /// permission checks or handling device opens specially).
    pub mode: Option<u32>,
    pub uid: Option<u32>,
    pub gid: Option<u32>,
    pub rdev: Option<u64>,
    /// Time of last access in nanoseconds since the Unix epoch, UTC. Note that servers might not
    /// always update this if this is the only attribute being updated.
    pub access_time: Option<u64>,
    /// Casefold (case-insensitive filename) support
    /// This attribute can only be changed on empty directories and will be inherited by any
    /// child directories that are subsequently created.
    /// The only filesystem to support this at the time of writing is Fxfs.
    pub casefold: Option<bool>,
    /// The value of the extended attribute "security.selinux" to be used in the context of SELinux
    /// implementations. The value can only be set or returned if it is
    /// [`MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN`] characters or less to constrain the size of the
    /// response. If the value is not currently found on the node the response the field will not
    /// be included in the repsonse. If the value is found on the node but the server is not
    /// returning it here due to size or implementation, then it will return
    /// `use_extended_attributes` to indicate using the ['fuchsia.io/Node.GetExtendedAttribute`]
    /// to retreive it.
    ///
    /// ZX_ERR_INVALID_ARGS will be returned if there is an attempt set this attribute with the
    /// `use_extended_attributes` member.
    pub selinux_context: Option<SelinuxContext>,
    /// Fscrypt support
    /// This attribute can only be changed on empty directories and will be inherited by any
    /// child directories that are subsequently created. This attribute can only be set once per
    /// directory. The wrapping_key_id set will be used to encrypt file contents and filenames for
    /// this directory and its children.
    /// The only filesystem to support this at the time of writing is Fxfs.
    pub wrapping_key_id: Option<[u8; 16]>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for MutableNodeAttributes {}

/// DEPRECATED - Use fuchsia.io/Flags + fuchsia.io/Options instead.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct NodeOptions {
    pub flags: Option<NodeFlags>,
    /// Callers may assert the type of the object by setting the protocol corresponding to the
    /// expected type:
    ///
    /// * If the caller expected a directory but the node cannot be accessed as a directory, the
    /// error is `ZX_ERR_NOT_DIR`.
    ///
    /// * If the caller expected a file but the node cannot be accessed as a file, the error is
    /// `ZX_ERR_NOT_FILE`.
    ///
    /// * In other mismatched cases, and for an empty table, the error is `ZX_ERR_WRONG_TYPE`.
    ///
    /// If more than one protocol is present, the resultant protocol may become any one of them.
    /// Callers should specify [`NodeFlags.GET_REPRESENTATION`] to receive a
    /// [`Node.OnRepresentation`] event, in order to ascertain the protocol.
    ///
    /// If absent, indicates that the caller accepts any [`Node`] protocol (including [`Node`]
    /// itself for connector nodes, for instance).
    pub protocols: Option<NodeProtocols>,
    /// Specifies how the target object should be created. If an object is to be created, its type
    /// must be specified by `protocols`. The check for existence and creation of the new object
    /// are performed atomically.
    ///
    /// If the type is ambiguous (e.g. both `directory` and `file` are set), the request must fail
    /// with `ZX_ERR_INVALID_ARGS`.
    pub mode: Option<CreationMode>,
    /// Requested rights on the new connection. If any [`rights`] exceed those of the current
    /// connection, [`object_request`] will be closed with `ZX_ERR_ACCESS_DENIED`.
    ///
    /// The rights granted to the connection will be downscoped to those operations the target
    /// node type supports. For example, if the target node is a file and both
    /// [`Rights.WRITE_BYTES`] and [`Rights.MODIFY_DIRECTORY`] are requested, the resulting
    /// connection will only be granted [`Rights.WRITE_BYTES`].
    ///
    /// If the rights field is absent, it is the equivalent of empty rights.
    pub rights: Option<Operations>,
    /// If the [`NodeFlags.GET_REPRESENTATION`] flag is set, attributes to be returned in
    /// [`Node.OnRepresentation`]. This requires the [`Rights.GET_ATTRIBUTES`] right on the parent
    /// connection, but not the resulting connection.
    pub attributes: Option<NodeAttributesQuery>,
    /// If an object is to be created, this specifies attributes that should be stored with the
    /// object at creation time. This requires the [`Rights.UPDATE_ATTRIBUTES`] right on the parent
    /// connection, but not the resulting connection. Requests will fail with `ZX_ERR_NOT_SUPPORTED`
    /// if any specified attributes are not supported.
    pub create_attributes: Option<MutableNodeAttributes>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for NodeOptions {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct NodeProtocols {
    pub directory: Option<DirectoryProtocolOptions>,
    pub file: Option<FileProtocolFlags>,
    pub symlink: Option<SymlinkProtocolFlags>,
    /// Asks for the node protocol. The only right supported is [`Rights.GET_ATTRIBUTES`].
    /// Calling `SetFlags` on the resulting connection will result in `ZX_ERR_BAD_HANDLE`. If
    /// [`NodeFlags.GET_REPRESENTATION`] is specified, the `connector` variant will be returned
    /// (even if the object supports a different representation).
    pub node: Option<NodeProtocolFlags>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for NodeProtocols {}

/// Options which can be used with Open3. Unlike [`Flags`], these options are designed for specific
/// use cases (e.g. to reduce round-trip latency when requesting attributes).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Options {
    /// Request a set of attributes to be sent with the OnRepresentation response. Has no effect
    /// if `Flags.FLAG_SEND_REPRESENTATION` is not set.
    pub attributes: Option<NodeAttributesQuery>,
    /// Request a set of attributes to be set atomically when creating a new object. Requests will
    /// fail with `ZX_ERR_INVALID_ARGS` if neither `Flags.FLAG_MAYBE_CREATE` nor
    /// `Flags.FLAG_MUST_CREATE` are set (i.e. the creation is mode is Never).
    pub create_attributes: Option<MutableNodeAttributes>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for Options {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SymlinkInfo {
    /// The symbolic link has no meaning on the server; the client is free to interpret the
    /// target however it chooses.
    pub target: Option<Vec<u8>>,
    /// Requested attributes for the symbolic link. This is only populated if requested.
    pub attributes: Option<NodeAttributes2>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SymlinkInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct UnlinkOptions {
    pub flags: Option<UnlinkFlags>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UnlinkOptions {}

/// Set of options used to enable verity on a file.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct VerificationOptions {
    pub hash_algorithm: Option<HashAlgorithm>,
    /// `salt` is prepended to each block before it is hashed.
    pub salt: Option<Vec<u8>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for VerificationOptions {}

#[derive(Clone, Debug)]
pub enum ConnectionProtocols {
    /// Requests that the node's underlying protocol be served on the connection.
    Connector(ConnectorFlags),
    /// Requests that the underlying [`Node`] protocol be served on the connection.
    Node(NodeOptions),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

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

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

impl ConnectionProtocols {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Connector(_) => 1,
            Self::Node(_) => 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::Persistable for ConnectionProtocols {}

/// 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(fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect> 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,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

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

#[derive(Debug)]
pub enum Representation {
    /// Auxiliary data for the connector representation of a node, used
    /// for protocol discovery and connection.
    ///
    /// It supports connecting to arbitrary protocols exported by the
    /// filesystem server at a path, including ones that do not compose
    /// [`Node2`].
    ///
    /// See [`NodeProtocolKinds.CONNECTOR`].
    Connector(ConnectorInfo),
    /// Auxiliary data for the directory representation of a node. The
    /// selection of this variant in [`Representation`] implies that the
    /// connection speaks the [`Directory`] protocol.
    ///
    /// See [`NodeProtocolKinds.DIRECTORY`].
    Directory(DirectoryInfo),
    /// Auxiliary data for the file representation of a node. The
    /// selection of this variant in [`Representation`] implies that the
    /// connection speaks the [`File`] protocol.
    ///
    /// See [`NodeProtocolKinds.FILE`].
    File(FileInfo),
    /// Auxilliary data for the symlink representation of a node. The
    /// selection of this variant in [`Representation`] implies that the
    /// connection speaks the [`Symlink`] protocol.
    ///
    /// See [`NodeProtocolKinds.SYMLINK`].
    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::Connector(x), Self::Connector(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::Connector(_) => 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<fidl::encoding::DefaultFuchsiaResourceDialect> for Representation {}

#[derive(Clone, Debug)]
pub enum SelinuxContext {
    Data(Vec<u8>),
    UseExtendedAttributes(EmptyStruct),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl SelinuxContext {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Data(_) => 1,
            Self::UseExtendedAttributes(_) => 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::Persistable for SelinuxContext {}

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

impl fidl::endpoints::ProtocolMarker for AdvisoryLockingMarker {
    type Proxy = AdvisoryLockingProxy;
    type RequestStream = AdvisoryLockingRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AdvisoryLockingSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct AdvisoryLockingSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AdvisoryLockingSynchronousProxy {
    type Proxy = AdvisoryLockingProxy;
    type Protocol = AdvisoryLockingMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl AdvisoryLockingSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <AdvisoryLockingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<AdvisoryLockingEvent, fidl::Error> {
        AdvisoryLockingEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
        let _response = self.client.send_query::<
            AdvisoryLockingAdvisoryLockRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl AdvisoryLockingProxy {
    /// Create a new Proxy for fuchsia.io/AdvisoryLocking.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AdvisoryLockingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl AdvisoryLockingProxyInterface for AdvisoryLockingProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for DirectoryMarker {
    type Proxy = DirectoryProxy;
    type RequestStream = DirectoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DirectorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.io.Directory";
}
impl fidl::endpoints::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#clone2(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_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#clone(
        &self,
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type GetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut;
    type SetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_flags(&self, flags: OpenFlags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetConnectionInfoResponseFut: std::future::Future<Output = Result<ConnectionInfo, fidl::Error>>
        + Send;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut;
    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: fidl::endpoints::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#open(
        &self,
        flags: OpenFlags,
        mode: ModeType,
        path: &str,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#open2(
        &self,
        path: &str,
        protocols: &ConnectionProtocols,
        object_request: fidl::Channel,
    ) -> Result<(), fidl::Error>;
    fn r#open3(
        &self,
        path: &str,
        flags: Flags,
        options: &Options,
        object: fidl::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<fidl::Handle>), 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: fidl::Handle, 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: fidl::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<fidl::endpoints::ServerEnd<SymlinkMarker>>,
    ) -> Self::CreateSymlinkResponseFut;
    type WatchResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#watch(
        &self,
        mask: WatchMask,
        options: u32,
        watcher: fidl::endpoints::ServerEnd<DirectoryWatcherMarker>,
    ) -> Self::WatchResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DirectorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DirectorySynchronousProxy {
    type Proxy = DirectoryProxy;
    type Protocol = DirectoryMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl DirectorySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DirectoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DirectoryEvent, fidl::Error> {
        DirectoryEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
        let _response = self.client.send_query::<
            AdvisoryLockingAdvisoryLockRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, NodeAttributes), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetAttrResponse>(
                (),
                0x78985e216314dafd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.attributes))
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetAttrRequest, NodeSetAttrResponse>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, OpenFlags), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetFlagsResponse>(
                (),
                0x5b88fffb8eda3aa1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.flags))
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetFlagsRequest, NodeSetFlagsResponse>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeQueryFilesystemResponse>(
                (),
                0x6f344a1c6b0a0610,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.info))
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectionInfo, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetAttributesRequest,
            fidl::encoding::ResultType<NodeAttributes2, i32>,
        >(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            MutableNodeAttributes,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<NodeSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetExtendedAttributeRequest,
            fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeSetExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeRemoveExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Opens a new object relative to this directory object.
    ///
    /// `path` may contain multiple segments, separated by "/" characters, and should never be
    /// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
    /// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
    /// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
    /// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
    ///
    /// If an unknown value is sent for flags the connection should be closed.
    ///
    /// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
    /// the `object` channel which will be connected to the opened entity.
    ///
    /// Rights are never increased. When you open a nested entity within a directory, you may only
    /// request the same rights as what the directory connection already has, or a subset of those.
    /// Exceeding those rights causes an access denied error to be transmitted in the
    /// `OnOpen` event if applicable, and the `object` connection closed.
    ///
    /// `mode` is ignored.
    pub fn r#open(
        &self,
        mut flags: OpenFlags,
        mut mode: ModeType,
        mut path: &str,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryOpenRequest>(
            (flags, mode, path, object),
            0x2c5044561d685ec0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Opens or creates a new node relative to this directory node.
    ///
    /// This method requires the following rights on the current connection:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.TRAVERSE`]
    ///
    /// Errors are presented as an epitaph on the `object_request` channel.
    ///
    /// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds what is allowed.
    /// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
    pub fn r#open2(
        &self,
        mut path: &str,
        mut protocols: &ConnectionProtocols,
        mut object_request: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryOpen2Request>(
            (path, protocols, object_request),
            0x2fbc4fbbff7c54d6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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#open3(
        &self,
        mut path: &str,
        mut flags: Flags,
        mut options: &Options,
        mut object: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryOpen3Request>(
            (path, flags, options, object),
            0x568ddcb9a9cbb6d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Vec<u8>), fidl::Error> {
        let _response =
            self.client.send_query::<DirectoryReadDirentsRequest, DirectoryReadDirentsResponse>(
                (max_bytes,),
                0x3582806bf27faa0a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.dirents))
    }

    /// Resets the directory seek offset.
    ///
    /// This method does not require any rights, similar to ReadDirents.
    pub fn r#rewind(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DirectoryRewindResponse>(
                (),
                0x16b1202af0f34c71,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.s)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<fidl::Handle>), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DirectoryGetTokenResponse>(
                (),
                0x26ae9d18763c8655,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.token))
    }

    /// 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: fidl::Handle,
        mut dst: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<DirectoryLinkRequest, DirectoryLinkResponse>(
            (src, dst_parent_token, dst),
            0x740604c0c7c930e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DirectoryUnlinkResult, fidl::Error> {
        let _response = self.client.send_query::<
            DirectoryUnlinkRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, options,),
            0x750a0326a78d7bed,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::Event,
        mut dst: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DirectoryRenameResult, fidl::Error> {
        let _response = self.client.send_query::<
            DirectoryRenameRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (src, dst_parent_token, dst,),
            0x7060e7723b9928de,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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<fidl::endpoints::ServerEnd<SymlinkMarker>>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DirectoryCreateSymlinkResult, fidl::Error> {
        let _response = self.client.send_query::<
            DirectoryCreateSymlinkRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, target, connection,),
            0x21ce0f19ec043889,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ServerEnd<DirectoryWatcherMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<DirectoryWatchRequest, DirectoryWatchResponse>(
            (mask, options, watcher),
            0x5717193a59d66d91,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DirectoryProxy {
    /// Create a new Proxy for fuchsia.io/Directory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DirectoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#clone2(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<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DirectoryProxyInterface::r#close(self)
    }

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

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#clone(self, flags, object)
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DirectoryProxyInterface::r#get_attr(self)
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DirectoryProxyInterface::r#set_attr(self, flags, attributes)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DirectoryProxyInterface::r#get_flags(self)
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DirectoryProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
    ) -> fidl::client::QueryResponseFut<ConnectionInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DirectoryProxyInterface::r#get_connection_info(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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DirectoryProxyInterface::r#remove_extended_attribute(self, name)
    }

    /// Opens a new object relative to this directory object.
    ///
    /// `path` may contain multiple segments, separated by "/" characters, and should never be
    /// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
    /// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
    /// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
    /// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
    ///
    /// If an unknown value is sent for flags the connection should be closed.
    ///
    /// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
    /// the `object` channel which will be connected to the opened entity.
    ///
    /// Rights are never increased. When you open a nested entity within a directory, you may only
    /// request the same rights as what the directory connection already has, or a subset of those.
    /// Exceeding those rights causes an access denied error to be transmitted in the
    /// `OnOpen` event if applicable, and the `object` connection closed.
    ///
    /// `mode` is ignored.
    pub fn r#open(
        &self,
        mut flags: OpenFlags,
        mut mode: ModeType,
        mut path: &str,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#open(self, flags, mode, path, object)
    }

    /// Opens or creates a new node relative to this directory node.
    ///
    /// This method requires the following rights on the current connection:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.TRAVERSE`]
    ///
    /// Errors are presented as an epitaph on the `object_request` channel.
    ///
    /// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds what is allowed.
    /// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
    pub fn r#open2(
        &self,
        mut path: &str,
        mut protocols: &ConnectionProtocols,
        mut object_request: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#open2(self, path, protocols, object_request)
    }

    /// 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#open3(
        &self,
        mut path: &str,
        mut flags: Flags,
        mut options: &Options,
        mut object: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        DirectoryProxyInterface::r#open3(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>), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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<fidl::Handle>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::Handle,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        DirectoryRenameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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<fidl::endpoints::ServerEnd<SymlinkMarker>>,
    ) -> fidl::client::QueryResponseFut<
        DirectoryCreateSymlinkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::endpoints::ServerEnd<DirectoryWatcherMarker>,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DirectoryProxyInterface::r#watch(self, mask, options, watcher)
    }
}

impl DirectoryProxyInterface for DirectoryProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ee9c0ad53ec87aa,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AdvisoryLockingAdvisoryLockRequest,
            AdvisoryLockingAdvisoryLockResult,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_flags(&self, mut flags: OpenFlags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 GetConnectionInfoResponseFut = fidl::client::QueryResponseFut<
        ConnectionInfo,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectionInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConnectionInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x584c377c7c0a6d0b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#sync(&self) -> Self::SyncResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a0b9f3a9bf9032d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NodeRemoveExtendedAttributeRequest,
            NodeRemoveExtendedAttributeResult,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#open2(
        &self,
        mut path: &str,
        mut protocols: &ConnectionProtocols,
        mut object_request: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DirectoryOpen2Request>(
            (path, protocols, object_request),
            0x2fbc4fbbff7c54d6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type ReadDirentsResponseFut = fidl::client::QueryResponseFut<
        (i32, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_dirents(&self, mut max_bytes: u64) -> Self::ReadDirentsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryReadDirentsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#rewind(&self) -> Self::RewindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryRewindResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::Handle>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_token(&self) -> Self::GetTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fidl::Handle>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryGetTokenResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x26ae9d18763c8655,
            >(_buf?)?;
            Ok((_response.s, _response.token))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<fidl::Handle>)>(
                (),
                0x26ae9d18763c8655,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type LinkResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#link(
        &self,
        mut src: &str,
        mut dst_parent_token: fidl::Handle,
        mut dst: &str,
    ) -> Self::LinkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryLinkResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#unlink(&self, mut name: &str, mut options: &UnlinkOptions) -> Self::UnlinkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#rename(
        &self,
        mut src: &str,
        mut dst_parent_token: fidl::Event,
        mut dst: &str,
    ) -> Self::RenameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_symlink(
        &self,
        mut name: &str,
        mut target: &[u8],
        mut connection: Option<fidl::endpoints::ServerEnd<SymlinkMarker>>,
    ) -> Self::CreateSymlinkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch(
        &self,
        mut mask: WatchMask,
        mut options: u32,
        mut watcher: fidl::endpoints::ServerEnd<DirectoryWatcherMarker>,
    ) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DirectoryWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ee9c0ad53ec87aa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AdvisoryLockingAdvisoryLockRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            fidl_fuchsia_unknown::CloneableClone2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableClone2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Clone2 { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            NodeCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Clone {
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetAttr {
                            responder: DirectoryGetAttrResponder {
                                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!(
                            NodeSetAttrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::SetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: DirectorySetAttrResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x584c377c7c0a6d0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::GetConnectionInfo {
                            responder: DirectoryGetConnectionInfoResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            DirectoryOpenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DirectoryOpenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Open {
                            flags: req.flags,
                            mode: req.mode,
                            path: req.path,
                            object: req.object,

                            control_handle,
                        })
                    }
                    0x2fbc4fbbff7c54d6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryOpen2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DirectoryOpen2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Open2 {
                            path: req.path,
                            protocols: req.protocols,
                            object_request: req.object_request,

                            control_handle,
                        })
                    }
                    0x568ddcb9a9cbb6d9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DirectoryOpen3Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DirectoryOpen3Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DirectoryControlHandle { inner: this.inner.clone() };
                        Ok(DirectoryRequest::Open3 {
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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,
    },
    Clone2 {
        request: fidl::endpoints::ServerEnd<fidl_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,
    },
    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    Clone {
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    GetAttr {
        responder: DirectoryGetAttrResponder,
    },
    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    SetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: DirectorySetAttrResponder,
    },
    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    GetFlags {
        responder: DirectoryGetFlagsResponder,
    },
    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    SetFlags {
        flags: OpenFlags,
        responder: DirectorySetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: DirectoryQueryFilesystemResponder,
    },
    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    GetConnectionInfo {
        responder: DirectoryGetConnectionInfoResponder,
    },
    /// 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: fidl::endpoints::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,
    },
    /// Opens a new object relative to this directory object.
    ///
    /// `path` may contain multiple segments, separated by "/" characters, and should never be
    /// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
    /// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
    /// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
    /// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
    ///
    /// If an unknown value is sent for flags the connection should be closed.
    ///
    /// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
    /// the `object` channel which will be connected to the opened entity.
    ///
    /// Rights are never increased. When you open a nested entity within a directory, you may only
    /// request the same rights as what the directory connection already has, or a subset of those.
    /// Exceeding those rights causes an access denied error to be transmitted in the
    /// `OnOpen` event if applicable, and the `object` connection closed.
    ///
    /// `mode` is ignored.
    Open {
        flags: OpenFlags,
        mode: ModeType,
        path: String,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
        control_handle: DirectoryControlHandle,
    },
    /// Opens or creates a new node relative to this directory node.
    ///
    /// This method requires the following rights on the current connection:
    ///
    /// * [`Rights.ENUMERATE`]
    /// * [`Rights.TRAVERSE`]
    ///
    /// Errors are presented as an epitaph on the `object_request` channel.
    ///
    /// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds what is allowed.
    /// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
    Open2 {
        path: String,
        protocols: ConnectionProtocols,
        object_request: fidl::Channel,
        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`
    Open3 {
        path: String,
        flags: Flags,
        options: Options,
        object: fidl::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: fidl::Handle,
        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: fidl::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<fidl::endpoints::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: fidl::endpoints::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_clone2(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        DirectoryControlHandle,
    )> {
        if let DirectoryRequest::Clone2 { 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_clone(
        self,
    ) -> Option<(OpenFlags, fidl::endpoints::ServerEnd<NodeMarker>, DirectoryControlHandle)> {
        if let DirectoryRequest::Clone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, DirectorySetAttrResponder)> {
        if let DirectoryRequest::SetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, 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<(OpenFlags, 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_connection_info(self) -> Option<(DirectoryGetConnectionInfoResponder)> {
        if let DirectoryRequest::GetConnectionInfo { 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<(fidl::endpoints::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_open(
        self,
    ) -> Option<(
        OpenFlags,
        ModeType,
        String,
        fidl::endpoints::ServerEnd<NodeMarker>,
        DirectoryControlHandle,
    )> {
        if let DirectoryRequest::Open { flags, mode, path, object, control_handle } = self {
            Some((flags, mode, path, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open2(
        self,
    ) -> Option<(String, ConnectionProtocols, fidl::Channel, DirectoryControlHandle)> {
        if let DirectoryRequest::Open2 { path, protocols, object_request, control_handle } = self {
            Some((path, protocols, object_request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open3(
        self,
    ) -> Option<(String, Flags, Options, fidl::Channel, DirectoryControlHandle)> {
        if let DirectoryRequest::Open3 { 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, fidl::Handle, 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, fidl::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<fidl::endpoints::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,
        fidl::endpoints::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::Clone2 { .. } => "clone2",
            DirectoryRequest::Close { .. } => "close",
            DirectoryRequest::Query { .. } => "query",
            DirectoryRequest::Clone { .. } => "clone",
            DirectoryRequest::GetAttr { .. } => "get_attr",
            DirectoryRequest::SetAttr { .. } => "set_attr",
            DirectoryRequest::GetFlags { .. } => "get_flags",
            DirectoryRequest::SetFlags { .. } => "set_flags",
            DirectoryRequest::QueryFilesystem { .. } => "query_filesystem",
            DirectoryRequest::GetConnectionInfo { .. } => "get_connection_info",
            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::Open { .. } => "open",
            DirectoryRequest::Open2 { .. } => "open2",
            DirectoryRequest::Open3 { .. } => "open3",
            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

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

    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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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::<fidl_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 DirectoryGetAttrResponder {
    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 DirectoryGetAttrResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DirectoryGetAttrResponder {
    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 DirectoryGetAttrResponder {
    /// 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::<NodeGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Responder for DirectorySetAttrResponder {
    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 DirectorySetAttrResponder {
    /// 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::<NodeSetAttrResponse>(
            (s,),
            self.tx_id,
            0x4186c0f40d938f46,
            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 fidl::endpoints::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 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::<NodeGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 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::<NodeSetFlagsResponse>(
            (s,),
            self.tx_id,
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 DirectoryGetConnectionInfoResponder {
    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 DirectoryGetConnectionInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

    fn send_raw(&self, mut payload: ConnectionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConnectionInfo>(
            &mut payload,
            self.tx_id,
            0x584c377c7c0a6d0b,
            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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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<fidl::Handle>) -> 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<fidl::Handle>,
    ) -> 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<fidl::Handle>) -> 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for DirectoryWatcherMarker {
    type Proxy = DirectoryWatcherProxy;
    type RequestStream = DirectoryWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DirectoryWatcherSynchronousProxy;

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

pub trait DirectoryWatcherProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DirectoryWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DirectoryWatcherSynchronousProxy {
    type Proxy = DirectoryWatcherProxy;
    type Protocol = DirectoryWatcherMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl DirectoryWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DirectoryWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DirectoryWatcherEvent, fidl::Error> {
        DirectoryWatcherEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DirectoryWatcherProxy {
    /// Create a new Proxy for fuchsia.io/DirectoryWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DirectoryWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl DirectoryWatcherProxyInterface for DirectoryWatcherProxy {}

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DirectoryWatcherMarker as fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DirectoryWatcherControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ExtendedAttributeIteratorMarker {
    type Proxy = ExtendedAttributeIteratorProxy;
    type RequestStream = ExtendedAttributeIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ExtendedAttributeIteratorSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct ExtendedAttributeIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ExtendedAttributeIteratorSynchronousProxy {
    type Proxy = ExtendedAttributeIteratorProxy;
    type Protocol = ExtendedAttributeIteratorMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl ExtendedAttributeIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ExtendedAttributeIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ExtendedAttributeIteratorEvent, fidl::Error> {
        ExtendedAttributeIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ExtendedAttributeIteratorGetNextResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<ExtendedAttributeIteratorGetNextResponse, i32>,
        >(
            (),
            0x3ba664a1c2e45a7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.attributes, x.last)))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ExtendedAttributeIteratorProxy {
    /// Create a new Proxy for fuchsia.io/ExtendedAttributeIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ExtendedAttributeIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl ExtendedAttributeIteratorProxyInterface for ExtendedAttributeIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        ExtendedAttributeIteratorGetNextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ExtendedAttributeIteratorGetNextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeIteratorGetNextResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for FileMarker {
    type Proxy = FileProxy;
    type RequestStream = FileRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FileSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.io.File";
}
impl fidl::endpoints::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<fidl::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: fidl::Event, dst: &str) -> Self::LinkIntoResponseFut;
    fn r#clone2(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_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#clone(
        &self,
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type GetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut;
    type SetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_flags(&self, flags: OpenFlags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetConnectionInfoResponseFut: std::future::Future<Output = Result<ConnectionInfo, fidl::Error>>
        + Send;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut;
    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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct FileSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FileSynchronousProxy {
    type Proxy = FileProxy;
    type Protocol = FileMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl FileSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <FileMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<FileEvent, fidl::Error> {
        FileEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AdvisoryLockingAdvisoryLockResult, fidl::Error> {
        let _response = self.client.send_query::<
            AdvisoryLockingAdvisoryLockRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (request,),
            0x6ee9c0ad53ec87aa,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, 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: fidl::Event,
        mut dst: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LinkableLinkIntoResult, fidl::Error> {
        let _response = self.client.send_query::<
            LinkableLinkIntoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (dst_parent_token, dst,),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, NodeAttributes), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetAttrResponse>(
                (),
                0x78985e216314dafd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.attributes))
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetAttrRequest, NodeSetAttrResponse>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, OpenFlags), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetFlagsResponse>(
                (),
                0x5b88fffb8eda3aa1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.flags))
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetFlagsRequest, NodeSetFlagsResponse>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeQueryFilesystemResponse>(
                (),
                0x6f344a1c6b0a0610,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.info))
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectionInfo, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetAttributesRequest,
            fidl::encoding::ResultType<NodeAttributes2, i32>,
        >(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            MutableNodeAttributes,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<NodeSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetExtendedAttributeRequest,
            fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeSetExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeRemoveExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReadableReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            ReadableReadRequest,
            fidl::encoding::ResultType<ReadableReadResponse, i32>,
        >(
            (count,),
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.data))
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WritableWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            WritableWriteRequest,
            fidl::encoding::ResultType<WritableWriteResponse, i32>,
        >(
            (data,),
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.actual_count))
    }

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileSeekResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<FileSeekRequest, fidl::encoding::ResultType<FileSeekResponse, i32>>(
                (origin, offset),
                0x78079168162c5207,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.offset_from_start))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileReadAtResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<FileReadAtRequest, fidl::encoding::ResultType<FileReadAtResponse, i32>>(
                (count, offset),
                0x1607a293a60d723e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.data))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileWriteAtResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<FileWriteAtRequest, fidl::encoding::ResultType<FileWriteAtResponse, i32>>(
                (data, offset),
                0x793eefc0045e792b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.actual_count))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileResizeResult, fidl::Error> {
        let _response = self.client.send_query::<
            FileResizeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (length,),
            0x2b80825f0535743a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileGetBackingMemoryResult, fidl::Error> {
        let _response = self.client.send_query::<
            FileGetBackingMemoryRequest,
            fidl::encoding::ResultType<FileGetBackingMemoryResponse, i32>,
        >(
            (flags,),
            0xa6a9e654cbf62b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }

    /// Pre-allocate on-disk space for this file.
    pub fn r#allocate(
        &self,
        mut offset: u64,
        mut length: u64,
        mut mode: AllocateMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileAllocateResult, fidl::Error> {
        let _response = self.client.send_query::<
            FileAllocateRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (offset, length, mode,),
            0x77fa0c330b57fd2e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FileMarker>("allocate")?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FileEnableVerityResult, fidl::Error> {
        let _response = self.client.send_query::<
            FileEnableVerityRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (options,),
            0x2c421ec3faaeb8bb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FileMarker>("enable_verity")?;
        Ok(_response.map(|x| x))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl FileProxy {
    /// Create a new Proxy for fuchsia.io/File.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FileMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, 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: fidl::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#link_into(self, dst_parent_token, dst)
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        FileProxyInterface::r#clone2(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<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#close(self)
    }

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

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        FileProxyInterface::r#clone(self, flags, object)
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#get_attr(self)
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        FileProxyInterface::r#set_attr(self, flags, attributes)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#get_flags(self)
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
    ) -> fidl::client::QueryResponseFut<ConnectionInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        FileProxyInterface::r#get_connection_info(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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#write(self, data)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<FileInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FileProxyInterface::r#enable_verity(self, options)
    }
}

impl FileProxyInterface for FileProxy {
    type AdvisoryLockResponseFut = fidl::client::QueryResponseFut<
        AdvisoryLockingAdvisoryLockResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#advisory_lock(&self, mut request: &AdvisoryLockRequest) -> Self::AdvisoryLockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fidl::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_flags(&self, mut flags: OpenFlags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 GetConnectionInfoResponseFut = fidl::client::QueryResponseFut<
        ConnectionInfo,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectionInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConnectionInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x584c377c7c0a6d0b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#sync(&self) -> Self::SyncResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self, mut count: u64) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReadableReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReadableReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WritableWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WritableWriteResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FileInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#seek(&self, mut origin: SeekOrigin, mut offset: i64) -> Self::SeekResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileSeekResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileSeekResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_at(&self, mut count: u64, mut offset: u64) -> Self::ReadAtResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileReadAtResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileReadAtResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_at(&self, mut data: &[u8], mut offset: u64) -> Self::WriteAtResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileWriteAtResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileWriteAtResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#resize(&self, mut length: u64) -> Self::ResizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_backing_memory(&self, mut flags: VmoFlags) -> Self::GetBackingMemoryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FileGetBackingMemoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileGetBackingMemoryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#allocate(
        &self,
        mut offset: u64,
        mut length: u64,
        mut mode: AllocateMode,
    ) -> Self::AllocateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x77fa0c330b57fd2e,
            >(_buf?)?
            .into_result::<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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#enable_verity(&self, mut options: &VerificationOptions) -> Self::EnableVerityResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c421ec3faaeb8bb,
            >(_buf?)?
            .into_result::<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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ee9c0ad53ec87aa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AdvisoryLockingAdvisoryLockRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            fidl_fuchsia_unknown::CloneableClone2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableClone2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Clone2 { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            NodeCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::Clone {
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetAttr {
                            responder: FileGetAttrResponder {
                                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!(
                            NodeSetAttrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::SetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: FileSetAttrResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x584c377c7c0a6d0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FileControlHandle { inner: this.inner.clone() };
                        Ok(FileRequest::GetConnectionInfo {
                            responder: FileGetConnectionInfoResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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, 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: fidl::Event,
        dst: String,
        responder: FileLinkIntoResponder,
    },
    Clone2 {
        request: fidl::endpoints::ServerEnd<fidl_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,
    },
    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    Clone {
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
        control_handle: FileControlHandle,
    },
    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    GetAttr {
        responder: FileGetAttrResponder,
    },
    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    SetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: FileSetAttrResponder,
    },
    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    GetFlags {
        responder: FileGetFlagsResponder,
    },
    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    SetFlags {
        flags: OpenFlags,
        responder: FileSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: FileQueryFilesystemResponder,
    },
    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    GetConnectionInfo {
        responder: FileGetConnectionInfoResponder,
    },
    /// 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: fidl::endpoints::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<(fidl::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_clone2(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        FileControlHandle,
    )> {
        if let FileRequest::Clone2 { 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_clone(
        self,
    ) -> Option<(OpenFlags, fidl::endpoints::ServerEnd<NodeMarker>, FileControlHandle)> {
        if let FileRequest::Clone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, FileSetAttrResponder)> {
        if let FileRequest::SetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, 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<(OpenFlags, 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_connection_info(self) -> Option<(FileGetConnectionInfoResponder)> {
        if let FileRequest::GetConnectionInfo { 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<(fidl::endpoints::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::Clone2 { .. } => "clone2",
            FileRequest::Close { .. } => "close",
            FileRequest::Query { .. } => "query",
            FileRequest::Clone { .. } => "clone",
            FileRequest::GetAttr { .. } => "get_attr",
            FileRequest::SetAttr { .. } => "set_attr",
            FileRequest::GetFlags { .. } => "get_flags",
            FileRequest::SetFlags { .. } => "set_flags",
            FileRequest::QueryFilesystem { .. } => "query_filesystem",
            FileRequest::GetConnectionInfo { .. } => "get_connection_info",
            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

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

    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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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::<fidl_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 FileGetAttrResponder {
    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 FileGetAttrResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FileGetAttrResponder {
    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 FileGetAttrResponder {
    /// 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::<NodeGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Responder for FileSetAttrResponder {
    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 FileSetAttrResponder {
    /// 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::<NodeSetAttrResponse>(
            (s,),
            self.tx_id,
            0x4186c0f40d938f46,
            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 fidl::endpoints::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 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::<NodeGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 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::<NodeSetFlagsResponse>(
            (s,),
            self.tx_id,
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 FileGetConnectionInfoResponder {
    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 FileGetConnectionInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

    fn send_raw(&self, mut payload: ConnectionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConnectionInfo>(
            &mut payload,
            self.tx_id,
            0x584c377c7c0a6d0b,
            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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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<fidl::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<fidl::Vmo, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<fidl::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for LinkableMarker {
    type Proxy = LinkableProxy;
    type RequestStream = LinkableRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LinkableSynchronousProxy;

    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: fidl::Event, dst: &str) -> Self::LinkIntoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LinkableSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LinkableSynchronousProxy {
    type Proxy = LinkableProxy;
    type Protocol = LinkableMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl LinkableSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <LinkableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<LinkableEvent, fidl::Error> {
        LinkableEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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, 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: fidl::Event,
        mut dst: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LinkableLinkIntoResult, fidl::Error> {
        let _response = self.client.send_query::<
            LinkableLinkIntoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (dst_parent_token, dst,),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl LinkableProxy {
    /// Create a new Proxy for fuchsia.io/Linkable.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LinkableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, 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: fidl::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LinkableProxyInterface::r#link_into(self, dst_parent_token, dst)
    }
}

impl LinkableProxyInterface for LinkableProxy {
    type LinkIntoResponseFut = fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fidl::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x54f3949246a03e74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinkableLinkIntoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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, 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: fidl::Event, dst: String, responder: LinkableLinkIntoResponder },
}

impl LinkableRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_link_into(self) -> Option<(fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for NodeMarker {
    type Proxy = NodeProxy;
    type RequestStream = NodeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NodeSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.io.Node";
}
impl fidl::endpoints::DiscoverableProtocolMarker for NodeMarker {}
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#clone2(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_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#clone(
        &self,
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type GetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut;
    type SetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_flags(&self, flags: OpenFlags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetConnectionInfoResponseFut: std::future::Future<Output = Result<ConnectionInfo, fidl::Error>>
        + Send;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut;
    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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct NodeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NodeSynchronousProxy {
    type Proxy = NodeProxy;
    type Protocol = NodeMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl NodeSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <NodeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<NodeEvent, fidl::Error> {
        NodeEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, NodeAttributes), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetAttrResponse>(
                (),
                0x78985e216314dafd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.attributes))
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetAttrRequest, NodeSetAttrResponse>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, OpenFlags), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetFlagsResponse>(
                (),
                0x5b88fffb8eda3aa1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.flags))
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetFlagsRequest, NodeSetFlagsResponse>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeQueryFilesystemResponse>(
                (),
                0x6f344a1c6b0a0610,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.info))
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectionInfo, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetAttributesRequest,
            fidl::encoding::ResultType<NodeAttributes2, i32>,
        >(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            MutableNodeAttributes,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<NodeSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetExtendedAttributeRequest,
            fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeSetExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeRemoveExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl NodeProxy {
    /// Create a new Proxy for fuchsia.io/Node.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NodeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#clone2(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<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NodeProxyInterface::r#close(self)
    }

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

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        NodeProxyInterface::r#clone(self, flags, object)
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NodeProxyInterface::r#get_attr(self)
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NodeProxyInterface::r#set_attr(self, flags, attributes)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NodeProxyInterface::r#get_flags(self)
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NodeProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
    ) -> fidl::client::QueryResponseFut<ConnectionInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        NodeProxyInterface::r#get_connection_info(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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NodeProxyInterface::r#remove_extended_attribute(self, name)
    }
}

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

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

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

    fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_flags(&self, mut flags: OpenFlags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 GetConnectionInfoResponseFut = fidl::client::QueryResponseFut<
        ConnectionInfo,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectionInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConnectionInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x584c377c7c0a6d0b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#sync(&self) -> Self::SyncResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_unknown::CloneableClone2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableClone2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::Clone2 { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            NodeCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::Clone {
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::GetAttr {
                            responder: NodeGetAttrResponder {
                                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!(
                            NodeSetAttrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::SetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: NodeSetAttrResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x584c377c7c0a6d0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NodeControlHandle { inner: this.inner.clone() };
                        Ok(NodeRequest::GetConnectionInfo {
                            responder: NodeGetConnectionInfoResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Node defines the minimal interface for entities which can be accessed in a filesystem.
#[derive(Debug)]
pub enum NodeRequest {
    Clone2 {
        request: fidl::endpoints::ServerEnd<fidl_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,
    },
    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    Clone {
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
        control_handle: NodeControlHandle,
    },
    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    GetAttr {
        responder: NodeGetAttrResponder,
    },
    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    SetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: NodeSetAttrResponder,
    },
    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    GetFlags {
        responder: NodeGetFlagsResponder,
    },
    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    SetFlags {
        flags: OpenFlags,
        responder: NodeSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: NodeQueryFilesystemResponder,
    },
    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    GetConnectionInfo {
        responder: NodeGetConnectionInfoResponder,
    },
    /// 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: fidl::endpoints::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_clone2(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        NodeControlHandle,
    )> {
        if let NodeRequest::Clone2 { 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_clone(
        self,
    ) -> Option<(OpenFlags, fidl::endpoints::ServerEnd<NodeMarker>, NodeControlHandle)> {
        if let NodeRequest::Clone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, NodeSetAttrResponder)> {
        if let NodeRequest::SetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, 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<(OpenFlags, 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_connection_info(self) -> Option<(NodeGetConnectionInfoResponder)> {
        if let NodeRequest::GetConnectionInfo { 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<(fidl::endpoints::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::Clone2 { .. } => "clone2",
            NodeRequest::Close { .. } => "close",
            NodeRequest::Query { .. } => "query",
            NodeRequest::Clone { .. } => "clone",
            NodeRequest::GetAttr { .. } => "get_attr",
            NodeRequest::SetAttr { .. } => "set_attr",
            NodeRequest::GetFlags { .. } => "get_flags",
            NodeRequest::SetFlags { .. } => "set_flags",
            NodeRequest::QueryFilesystem { .. } => "query_filesystem",
            NodeRequest::GetConnectionInfo { .. } => "get_connection_info",
            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

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

    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 fidl::endpoints::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 fidl::endpoints::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::<fidl_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 NodeGetAttrResponder {
    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 NodeGetAttrResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for NodeGetAttrResponder {
    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 NodeGetAttrResponder {
    /// 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::<NodeGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Responder for NodeSetAttrResponder {
    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 NodeSetAttrResponder {
    /// 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::<NodeSetAttrResponse>(
            (s,),
            self.tx_id,
            0x4186c0f40d938f46,
            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 fidl::endpoints::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 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::<NodeGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 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::<NodeSetFlagsResponse>(
            (s,),
            self.tx_id,
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 NodeGetConnectionInfoResponder {
    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 NodeGetConnectionInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

    fn send_raw(&self, mut payload: ConnectionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConnectionInfo>(
            &mut payload,
            self.tx_id,
            0x584c377c7c0a6d0b,
            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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for ReadableMarker {
    type Proxy = ReadableProxy;
    type RequestStream = ReadableRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ReadableSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct ReadableSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ReadableSynchronousProxy {
    type Proxy = ReadableProxy;
    type Protocol = ReadableMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl ReadableSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ReadableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ReadableEvent, fidl::Error> {
        ReadableEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReadableReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            ReadableReadRequest,
            fidl::encoding::ResultType<ReadableReadResponse, i32>,
        >(
            (count,),
            0x57e419a298c8ede,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.data))
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ReadableProxy {
    /// Create a new Proxy for fuchsia.io/Readable.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ReadableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl ReadableProxyInterface for ReadableProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        ReadableReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self, mut count: u64) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ReadableReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ReadableReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for ReadableRequestStream {
    type Protocol = ReadableMarker;
    type ControlHandle = ReadableControlHandle;

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

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

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

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

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

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

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

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for SymlinkMarker {
    type Proxy = SymlinkProxy;
    type RequestStream = SymlinkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SymlinkSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.io.Symlink";
}
impl fidl::endpoints::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: fidl::Event, dst: &str) -> Self::LinkIntoResponseFut;
    fn r#clone2(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_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#clone(
        &self,
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error>;
    type GetAttrResponseFut: std::future::Future<Output = Result<(i32, NodeAttributes), fidl::Error>>
        + Send;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut;
    type SetAttrResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_attr(
        &self,
        flags: NodeAttributeFlags,
        attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut;
    type GetFlagsResponseFut: std::future::Future<Output = Result<(i32, OpenFlags), fidl::Error>>
        + Send;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut;
    type SetFlagsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_flags(&self, flags: OpenFlags) -> Self::SetFlagsResponseFut;
    type QueryFilesystemResponseFut: std::future::Future<Output = Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error>>
        + Send;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut;
    type GetConnectionInfoResponseFut: std::future::Future<Output = Result<ConnectionInfo, fidl::Error>>
        + Send;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut;
    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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct SymlinkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SymlinkSynchronousProxy {
    type Proxy = SymlinkProxy;
    type Protocol = SymlinkMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl SymlinkSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SymlinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<SymlinkEvent, fidl::Error> {
        SymlinkEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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, 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: fidl::Event,
        mut dst: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LinkableLinkIntoResult, fidl::Error> {
        let _response = self.client.send_query::<
            LinkableLinkIntoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (dst_parent_token, dst,),
            0x54f3949246a03e74,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, NodeAttributes), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetAttrResponse>(
                (),
                0x78985e216314dafd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.attributes))
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetAttrRequest, NodeSetAttrResponse>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, OpenFlags), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeGetFlagsResponse>(
                (),
                0x5b88fffb8eda3aa1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.flags))
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<NodeSetFlagsRequest, NodeSetFlagsResponse>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.s)
    }

    /// Query the filesystem for filesystem-specific information.
    pub fn r#query_filesystem(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, NodeQueryFilesystemResponse>(
                (),
                0x6f344a1c6b0a0610,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.s, _response.info))
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectionInfo, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetAttributesRequest,
            fidl::encoding::ResultType<NodeAttributes2, i32>,
        >(
            (query,),
            0x3d4396a638ea053b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.mutable_attributes, x.immutable_attributes)))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeUpdateAttributesResult, fidl::Error> {
        let _response = self.client.send_query::<
            MutableNodeAttributes,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x3308c1da5a89bf08,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<NodeSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x2c5c27ca0ab5dc49,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeGetExtendedAttributeRequest,
            fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
        >(
            (name,),
            0x45ffa3ccfdeb76db,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeSetExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeSetExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, &mut value, mode,),
            0x4a951362f681f23c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NodeRemoveExtendedAttributeResult, fidl::Error> {
        let _response = self.client.send_query::<
            NodeRemoveExtendedAttributeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name,),
            0x7a0b9f3a9bf9032d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#describe(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SymlinkInfo, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleType<SymlinkInfo>>(
                (),
                0x742c2ea5e89831f3,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                ___deadline,
            )?
            .into_result::<SymlinkMarker>("describe")?;
        Ok(_response)
    }
}

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

impl fidl::endpoints::Proxy for SymlinkProxy {
    type Protocol = SymlinkMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl SymlinkProxy {
    /// Create a new Proxy for fuchsia.io/Symlink.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SymlinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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, 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: fidl::Event,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#link_into(self, dst_parent_token, dst)
    }

    pub fn r#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        SymlinkProxyInterface::r#clone2(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<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SymlinkProxyInterface::r#query(self)
    }

    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    pub fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        SymlinkProxyInterface::r#clone(self, flags, object)
    }

    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    pub fn r#get_attr(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#get_attr(self)
    }

    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    pub fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        SymlinkProxyInterface::r#set_attr(self, flags, attributes)
    }

    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    pub fn r#get_flags(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#get_flags(self)
    }

    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    pub fn r#set_flags(
        &self,
        mut flags: OpenFlags,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#query_filesystem(self)
    }

    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    pub fn r#get_connection_info(
        &self,
    ) -> fidl::client::QueryResponseFut<ConnectionInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SymlinkProxyInterface::r#get_connection_info(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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::endpoints::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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SymlinkProxyInterface::r#remove_extended_attribute(self, name)
    }

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

impl SymlinkProxyInterface for SymlinkProxy {
    type LinkIntoResponseFut = fidl::client::QueryResponseFut<
        LinkableLinkIntoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#link_into(
        &self,
        mut dst_parent_token: fidl::Event,
        mut dst: &str,
    ) -> Self::LinkIntoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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#clone2(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableClone2Request>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    fn r#clone(
        &self,
        mut flags: OpenFlags,
        mut object: fidl::endpoints::ServerEnd<NodeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeCloneRequest>(
            (flags, object),
            0x5a61678f293ce16f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetAttrResponseFut = fidl::client::QueryResponseFut<
        (i32, NodeAttributes),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attr(&self) -> Self::GetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, NodeAttributes), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetAttrResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_attr(
        &self,
        mut flags: NodeAttributeFlags,
        mut attributes: &NodeAttributes,
    ) -> Self::SetAttrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetAttrResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4186c0f40d938f46,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetAttrRequest, i32>(
            (flags, attributes),
            0x4186c0f40d938f46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFlagsResponseFut = fidl::client::QueryResponseFut<
        (i32, OpenFlags),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_flags(&self) -> Self::GetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, OpenFlags), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeGetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 SetFlagsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_flags(&self, mut flags: OpenFlags) -> Self::SetFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeSetFlagsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5295b76c71fde733,
            >(_buf?)?;
            Ok(_response.s)
        }
        self.client.send_query_and_decode::<NodeSetFlagsRequest, i32>(
            (flags,),
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryFilesystemResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<FilesystemInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_filesystem(&self) -> Self::QueryFilesystemResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<FilesystemInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NodeQueryFilesystemResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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 GetConnectionInfoResponseFut = fidl::client::QueryResponseFut<
        ConnectionInfo,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_connection_info(&self) -> Self::GetConnectionInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectionInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConnectionInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x584c377c7c0a6d0b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ConnectionInfo>(
            (),
            0x584c377c7c0a6d0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAttributesResponseFut = fidl::client::QueryResponseFut<
        NodeGetAttributesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_attributes(&self, mut query: NodeAttributesQuery) -> Self::GetAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetAttributesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NodeAttributes2, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_attributes(
        &self,
        mut payload: &MutableNodeAttributes,
    ) -> Self::UpdateAttributesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#sync(&self) -> Self::SyncResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeSyncResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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: fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NodeListExtendedAttributesRequest>(
            (iterator,),
            0x4b61033de007fcd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetExtendedAttributeResponseFut = fidl::client::QueryResponseFut<
        NodeGetExtendedAttributeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_extended_attribute(&self, mut name: &[u8]) -> Self::GetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NodeGetExtendedAttributeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ExtendedAttributeValue, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_extended_attribute(
        &self,
        mut name: &[u8],
        mut value: ExtendedAttributeValue,
        mut mode: SetExtendedAttributeMode,
    ) -> Self::SetExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_extended_attribute(
        &self,
        mut name: &[u8],
    ) -> Self::RemoveExtendedAttributeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SymlinkInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<SymlinkInfo>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x742c2ea5e89831f3,
            >(_buf?)?
            .into_result::<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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

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

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

impl fidl::endpoints::RequestStream for SymlinkRequestStream {
    type Protocol = SymlinkMarker;
    type ControlHandle = SymlinkControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x54f3949246a03e74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LinkableLinkIntoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            fidl_fuchsia_unknown::CloneableClone2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableClone2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Clone2 { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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!(
                            NodeCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::Clone {
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::GetAttr {
                            responder: SymlinkGetAttrResponder {
                                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!(
                            NodeSetAttrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NodeSetAttrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::SetAttr {
                            flags: req.flags,
                            attributes: req.attributes,

                            responder: SymlinkSetAttrResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x5295b76c71fde733 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NodeSetFlagsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x584c377c7c0a6d0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SymlinkControlHandle { inner: this.inner.clone() };
                        Ok(SymlinkRequest::GetConnectionInfo {
                            responder: SymlinkGetConnectionInfoResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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, 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: fidl::Event,
        dst: String,
        responder: SymlinkLinkIntoResponder,
    },
    Clone2 {
        request: fidl::endpoints::ServerEnd<fidl_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,
    },
    /// Create another connection to the same remote object.
    ///
    /// `flags` may be any of:
    ///
    /// - `OpenFlags.RIGHT_*`
    /// - `OpenFlags.APPEND`
    /// - `OpenFlags.DESCRIBE`
    /// - `OpenFlags.CLONE_SAME_RIGHTS`
    ///
    /// All other flags are ignored.
    ///
    /// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
    /// cloned object.
    /// The cloned object must have rights less than or equal to the original object, otherwise
    /// returns `ZX_ERR_ACCESS_DENIED`.
    /// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
    /// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
    /// `OpenFlags.CLONE_SAME_RIGHTS`.
    Clone {
        flags: OpenFlags,
        object: fidl::endpoints::ServerEnd<NodeMarker>,
        control_handle: SymlinkControlHandle,
    },
    /// Acquires information about the node.
    ///
    /// This method does not require any rights.
    GetAttr {
        responder: SymlinkGetAttrResponder,
    },
    /// Updates information about the node.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.
    ///
    /// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
    /// `ZX_ERR_BAD_HANDLE`.
    SetAttr {
        flags: NodeAttributeFlags,
        attributes: NodeAttributes,
        responder: SymlinkSetAttrResponder,
    },
    /// Acquires the `Directory.Open` rights and flags used to access this file.
    ///
    /// This method does not require any rights.
    GetFlags {
        responder: SymlinkGetFlagsResponder,
    },
    /// Changes the `Directory.Open` flags used to access the file.
    /// Supported flags which can be turned on / off:
    /// - `OpenFlags.APPEND`
    ///
    /// This method does not require any rights.
    SetFlags {
        flags: OpenFlags,
        responder: SymlinkSetFlagsResponder,
    },
    /// Query the filesystem for filesystem-specific information.
    QueryFilesystem {
        responder: SymlinkQueryFilesystemResponder,
    },
    /// Acquires information about the connection.
    ///
    /// This method does not require any rights.
    GetConnectionInfo {
        responder: SymlinkGetConnectionInfoResponder,
    },
    /// 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: fidl::endpoints::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<(fidl::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_clone2(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        SymlinkControlHandle,
    )> {
        if let SymlinkRequest::Clone2 { 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_clone(
        self,
    ) -> Option<(OpenFlags, fidl::endpoints::ServerEnd<NodeMarker>, SymlinkControlHandle)> {
        if let SymlinkRequest::Clone { flags, object, control_handle } = self {
            Some((flags, object, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_attr(self) -> Option<(SymlinkGetAttrResponder)> {
        if let SymlinkRequest::GetAttr { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_attr(
        self,
    ) -> Option<(NodeAttributeFlags, NodeAttributes, SymlinkSetAttrResponder)> {
        if let SymlinkRequest::SetAttr { flags, attributes, responder } = self {
            Some((flags, attributes, 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<(OpenFlags, 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_connection_info(self) -> Option<(SymlinkGetConnectionInfoResponder)> {
        if let SymlinkRequest::GetConnectionInfo { 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<(fidl::endpoints::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::Clone2 { .. } => "clone2",
            SymlinkRequest::Close { .. } => "close",
            SymlinkRequest::Query { .. } => "query",
            SymlinkRequest::Clone { .. } => "clone",
            SymlinkRequest::GetAttr { .. } => "get_attr",
            SymlinkRequest::SetAttr { .. } => "set_attr",
            SymlinkRequest::GetFlags { .. } => "get_flags",
            SymlinkRequest::SetFlags { .. } => "set_flags",
            SymlinkRequest::QueryFilesystem { .. } => "query_filesystem",
            SymlinkRequest::GetConnectionInfo { .. } => "get_connection_info",
            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

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

    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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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::<fidl_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 SymlinkGetAttrResponder {
    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 SymlinkGetAttrResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SymlinkGetAttrResponder {
    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 SymlinkGetAttrResponder {
    /// 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::<NodeGetAttrResponse>(
            (s, attributes),
            self.tx_id,
            0x78985e216314dafd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Responder for SymlinkSetAttrResponder {
    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 SymlinkSetAttrResponder {
    /// 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::<NodeSetAttrResponse>(
            (s,),
            self.tx_id,
            0x4186c0f40d938f46,
            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 fidl::endpoints::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 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::<NodeGetFlagsResponse>(
            (s, flags),
            self.tx_id,
            0x5b88fffb8eda3aa1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 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::<NodeSetFlagsResponse>(
            (s,),
            self.tx_id,
            0x5295b76c71fde733,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 fidl::endpoints::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 SymlinkGetConnectionInfoResponder {
    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 SymlinkGetConnectionInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

    fn send_raw(&self, mut payload: ConnectionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConnectionInfo>(
            &mut payload,
            self.tx_id,
            0x584c377c7c0a6d0b,
            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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for WritableMarker {
    type Proxy = WritableProxy;
    type RequestStream = WritableRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WritableSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct WritableSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WritableSynchronousProxy {
    type Proxy = WritableProxy;
    type Protocol = WritableMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl WritableSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <WritableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<WritableEvent, fidl::Error> {
        WritableEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// 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],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WritableWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            WritableWriteRequest,
            fidl::encoding::ResultType<WritableWriteResponse, i32>,
        >(
            (data,),
            0x6a31437832469f82,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.actual_count))
    }
}

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

impl fidl::endpoints::Proxy for WritableProxy {
    type Protocol = WritableMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl WritableProxy {
    /// Create a new Proxy for fuchsia.io/Writable.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <WritableMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl WritableProxyInterface for WritableProxy {
    type WriteResponseFut = fidl::client::QueryResponseFut<
        WritableWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WritableWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WritableWriteResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WritableRequestStream {
    type Protocol = WritableMarker;
    type ControlHandle = WritableControlHandle;

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

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

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

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

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

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

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

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl 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 fidl::endpoints::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::*;
    unsafe impl fidl::encoding::TypeMarker for AllocateMode {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for AllocateMode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AllocateMode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllocateMode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ConnectorFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for ConnectorFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ConnectorFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectorFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for FileProtocolFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for FileProtocolFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for FileProtocolFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileProtocolFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for FileSignal {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileSignal {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FileSignal {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileSignal {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Flags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for Flags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Flags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Flags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ModeType {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for ModeType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ModeType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ModeType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NodeAttributeFlags {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeAttributeFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NodeAttributeFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeAttributeFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NodeAttributesQuery {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for NodeAttributesQuery {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NodeAttributesQuery
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeAttributesQuery {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NodeFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for NodeFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NodeProtocolFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for NodeProtocolFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NodeProtocolFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProtocolFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NodeProtocolKinds {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for NodeProtocolKinds {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NodeProtocolKinds
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProtocolKinds {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for OpenFlags {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for OpenFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Operations {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for Operations {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Operations {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Operations {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for SymlinkProtocolFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for SymlinkProtocolFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for SymlinkProtocolFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SymlinkProtocolFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for UnlinkFlags {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for UnlinkFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UnlinkFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnlinkFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for VmoFlags {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for VmoFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VmoFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmoFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for WatchMask {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for WatchMask {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WatchMask {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatchMask {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AdvisoryLockType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for AdvisoryLockType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for AdvisoryLockType
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvisoryLockType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Read
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for CreationMode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for CreationMode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreationMode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreationMode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Never
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for DirentType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirentType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DirentType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DirentType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for HashAlgorithm {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for HashAlgorithm {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HashAlgorithm {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HashAlgorithm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for SeekOrigin {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for SeekOrigin {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SeekOrigin {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SeekOrigin {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Start
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for SetExtendedAttributeMode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for SetExtendedAttributeMode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for SetExtendedAttributeMode
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for SetExtendedAttributeMode
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Set
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for WatchEvent {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for WatchEvent {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WatchEvent {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatchEvent {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Deleted
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for AdvisoryLockRange {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AdvisoryLockRange {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvisoryLockRange, D>
        for &AdvisoryLockRange
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvisoryLockRange>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AdvisoryLockRange, D>::encode(
                (
                    <SeekOrigin as fidl::encoding::ValueTypeMarker>::borrow(&self.origin),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.offset),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.length),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<SeekOrigin, D>,
            T1: fidl::encoding::Encode<i64, D>,
            T2: fidl::encoding::Encode<i64, D>,
        > fidl::encoding::Encode<AdvisoryLockRange, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvisoryLockRange>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvisoryLockRange {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                origin: fidl::new_empty!(SeekOrigin, D),
                offset: fidl::new_empty!(i64, D),
                length: fidl::new_empty!(i64, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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!(SeekOrigin, D, &mut self.origin, decoder, offset + 0, _depth)?;
            fidl::decode!(i64, D, &mut self.offset, decoder, offset + 8, _depth)?;
            fidl::decode!(i64, D, &mut self.length, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for AdvisoryLockingAdvisoryLockRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AdvisoryLockingAdvisoryLockRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<AdvisoryLockingAdvisoryLockRequest, D>
        for &AdvisoryLockingAdvisoryLockRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvisoryLockingAdvisoryLockRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AdvisoryLockingAdvisoryLockRequest, D>::encode(
                (<AdvisoryLockRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.request),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<AdvisoryLockRequest, D>,
        > fidl::encoding::Encode<AdvisoryLockingAdvisoryLockRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvisoryLockingAdvisoryLockRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for AdvisoryLockingAdvisoryLockRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { request: fidl::new_empty!(AdvisoryLockRequest, D) }
        }

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

    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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DirectoryCreateSymlinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryCreateSymlinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryCreateSymlinkRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::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<fidl::endpoints::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Vector<u8, 4095>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SymlinkMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DirectoryCreateSymlinkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryCreateSymlinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                target: fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, fidl::encoding::DefaultFuchsiaResourceDialect),
                connection: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SymlinkMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 4095>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.target, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SymlinkMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.connection,
                decoder,
                offset + 32,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DirectoryGetTokenResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryGetTokenResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryGetTokenResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Handle,
                            { 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, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Handle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DirectoryGetTokenResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryGetTokenResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
                token: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Handle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                i32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.s,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Handle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryLinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryLinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryLinkRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.src,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::Handle,
                        { 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Handle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<DirectoryLinkRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryLinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.src,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.dst_parent_token, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dst,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryLinkResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryLinkResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DirectoryLinkResponse, D>
        for &DirectoryLinkResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryLinkResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DirectoryLinkResponse)
                    .write_unaligned((self as *const DirectoryLinkResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<DirectoryLinkResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryLinkResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DirectoryLinkResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryObject {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryObject {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DirectoryObject, D>
        for &DirectoryObject
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryObject>(offset);
            encoder.write_num(0u8, offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DirectoryObject {
        #[inline(always)]
        fn new_empty() -> Self {
            Self
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DirectoryOpen2Request {
        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 DirectoryOpen2Request {
        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<DirectoryOpen2Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryOpen2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpen2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryOpen2Request, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <ConnectionProtocols as fidl::encoding::ValueTypeMarker>::borrow(&self.protocols),
                    <fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object_request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                ConnectionProtocols,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<DirectoryOpen2Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpen2Request>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryOpen2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                protocols: fidl::new_empty!(
                    ConnectionProtocols,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                object_request: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            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<4095>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ConnectionProtocols,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.protocols,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.object_request, decoder, offset + 32, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DirectoryOpen3Request {
        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 DirectoryOpen3Request {
        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<DirectoryOpen3Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryOpen3Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpen3Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryOpen3Request, fidl::encoding::DefaultFuchsiaResourceDialect>::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<fidl::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<Flags, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<Options, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T3: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<DirectoryOpen3Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpen3Request>(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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryOpen3Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                flags: fidl::new_empty!(Flags, fidl::encoding::DefaultFuchsiaResourceDialect),
                options: fidl::new_empty!(Options, fidl::encoding::DefaultFuchsiaResourceDialect),
                object: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Flags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.flags,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                Options,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.object, decoder, offset + 40, _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 {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<DirectoryOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::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<fidl::endpoints::ServerEnd<NodeMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<OpenFlags, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<ModeType, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<DirectoryOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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(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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                flags: fidl::new_empty!(OpenFlags, fidl::encoding::DefaultFuchsiaResourceDialect),
                mode: fidl::new_empty!(ModeType, fidl::encoding::DefaultFuchsiaResourceDialect),
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                OpenFlags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.flags,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ModeType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mode,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<4095>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.path,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.object,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryReadDirentsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryReadDirentsRequest {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryReadDirentsRequest, D> for &DirectoryReadDirentsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryReadDirentsRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DirectoryReadDirentsRequest)
                    .write_unaligned((self as *const DirectoryReadDirentsRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<DirectoryReadDirentsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryReadDirentsRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryReadDirentsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { max_bytes: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryReadDirentsResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryReadDirentsResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryReadDirentsResponse, D> for &DirectoryReadDirentsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryReadDirentsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryReadDirentsResponse, D>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.dirents,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<i32, D>,
            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
        > fidl::encoding::Encode<DirectoryReadDirentsResponse, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryReadDirentsResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryReadDirentsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, D),
                dirents: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, D, &mut self.s, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.dirents, decoder, offset + 8, _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DirectoryRenameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryRenameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DirectoryRenameRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.src,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DirectoryRenameRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryRenameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.src,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.dst_parent_token, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dst,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryRewindResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryRewindResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryRewindResponse, D> for &DirectoryRewindResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryRewindResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DirectoryRewindResponse)
                    .write_unaligned((self as *const DirectoryRewindResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<DirectoryRewindResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryRewindResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryRewindResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryUnlinkRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryUnlinkRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryUnlinkRequest, D> for &DirectoryUnlinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryUnlinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryUnlinkRequest, D>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <UnlinkOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
            T1: fidl::encoding::Encode<UnlinkOptions, D>,
        > fidl::encoding::Encode<DirectoryUnlinkRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryUnlinkRequest>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryUnlinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
                options: fidl::new_empty!(UnlinkOptions, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                D,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(UnlinkOptions, D, &mut self.options, decoder, offset + 16, _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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryWatchRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryWatchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryWatchRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <WatchMask as fidl::encoding::ValueTypeMarker>::borrow(&self.mask),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DirectoryWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<WatchMask, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DirectoryWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<DirectoryWatchRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryWatchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mask: fidl::new_empty!(WatchMask, fidl::encoding::DefaultFuchsiaResourceDialect),
                options: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DirectoryWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                WatchMask,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mask,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DirectoryWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.watcher,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryWatchResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryWatchResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryWatchResponse, D> for &DirectoryWatchResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryWatchResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DirectoryWatchResponse)
                    .write_unaligned((self as *const DirectoryWatchResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<DirectoryWatchResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryWatchResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryWatchResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for EmptyStruct {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EmptyStruct {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EmptyStruct, D>
        for &EmptyStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyStruct>(offset);
            encoder.write_num(0u8, offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EmptyStruct {
        #[inline(always)]
        fn new_empty() -> Self {
            Self
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

    impl fidl::encoding::ValueTypeMarker for ExtendedAttributeIteratorGetNextResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ExtendedAttributeIteratorGetNextResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ExtendedAttributeIteratorGetNextResponse, D>
        for &ExtendedAttributeIteratorGetNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExtendedAttributeIteratorGetNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ExtendedAttributeIteratorGetNextResponse, D>::encode(
                (
                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.last),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 128>, D>,
            T1: fidl::encoding::Encode<bool, D>,
        > fidl::encoding::Encode<ExtendedAttributeIteratorGetNextResponse, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExtendedAttributeIteratorGetNextResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ExtendedAttributeIteratorGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                attributes: fidl::new_empty!(
                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 128>,
                    D
                ),
                last: fidl::new_empty!(bool, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 = 0xffffffffffffff00u64;
            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::Vector<fidl::encoding::Vector<u8, 255>, 128>,
                D,
                &mut self.attributes,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.last, decoder, offset + 16, _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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FileAllocateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileAllocateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileAllocateRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<AllocateMode, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<FileAllocateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FileAllocateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                offset: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                length: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                mode: fidl::new_empty!(AllocateMode, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

    impl fidl::encoding::ValueTypeMarker for FileGetBackingMemoryRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileGetBackingMemoryRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FileGetBackingMemoryRequest, D> for &FileGetBackingMemoryRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileGetBackingMemoryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileGetBackingMemoryRequest, D>::encode(
                (<VmoFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<VmoFlags, D>>
        fidl::encoding::Encode<FileGetBackingMemoryRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileGetBackingMemoryRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FileGetBackingMemoryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { flags: fidl::new_empty!(VmoFlags, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(VmoFlags, D, &mut self.flags, 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FileObject
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileObject>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileObject, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.event),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::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<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Stream,
                        { fidl::ObjectType::STREAM.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        > fidl::encoding::Encode<FileObject, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect> for FileObject {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                event: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                stream: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Stream,
                            { fidl::ObjectType::STREAM.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.event,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Stream,
                        { fidl::ObjectType::STREAM.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.stream,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileReadAtRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileReadAtRequest {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileReadAtRequest, D>
        for &FileReadAtRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileReadAtRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FileReadAtRequest)
                    .write_unaligned((self as *const FileReadAtRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u64, D>,
            T1: fidl::encoding::Encode<u64, D>,
        > fidl::encoding::Encode<FileReadAtRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileReadAtRequest>(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 + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileReadAtRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { count: fidl::new_empty!(u64, D), offset: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileResizeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileResizeRequest {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileResizeRequest, D>
        for &FileResizeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileResizeRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FileResizeRequest)
                    .write_unaligned((self as *const FileResizeRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<FileResizeRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileResizeRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileResizeRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { length: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileSeekRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileSeekRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileSeekRequest, D>
        for &FileSeekRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileSeekRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileSeekRequest, D>::encode(
                (
                    <SeekOrigin as fidl::encoding::ValueTypeMarker>::borrow(&self.origin),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.offset),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<SeekOrigin, D>,
            T1: fidl::encoding::Encode<i64, D>,
        > fidl::encoding::Encode<FileSeekRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileSeekRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileSeekRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { origin: fidl::new_empty!(SeekOrigin, D), offset: fidl::new_empty!(i64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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!(SeekOrigin, D, &mut self.origin, decoder, offset + 0, _depth)?;
            fidl::decode!(i64, D, &mut self.offset, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileWriteAtRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileWriteAtRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileWriteAtRequest, D>
        for &FileWriteAtRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileWriteAtRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileWriteAtRequest, D>::encode(
                (
                    <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.data,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.offset),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
            T1: fidl::encoding::Encode<u64, D>,
        > fidl::encoding::Encode<FileWriteAtRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileWriteAtRequest>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileWriteAtRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
                offset: fidl::new_empty!(u64, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 0, _depth)?;
            fidl::decode!(u64, D, &mut self.offset, decoder, offset + 16, _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FileGetBackingMemoryResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileGetBackingMemoryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileGetBackingMemoryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::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<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FileGetBackingMemoryResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FileGetBackingMemoryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileReadAtResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileReadAtResponse {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileReadAtResponse, D>
        for &FileReadAtResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileReadAtResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FileReadAtResponse, D>::encode(
                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.data,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
        > fidl::encoding::Encode<FileReadAtResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileReadAtResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileReadAtResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for FileSeekResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileSeekResponse {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileSeekResponse, D>
        for &FileSeekResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileSeekResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FileSeekResponse)
                    .write_unaligned((self as *const FileSeekResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<FileSeekResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileSeekResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileSeekResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { offset_from_start: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FileWriteAtResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FileWriteAtResponse {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileWriteAtResponse, D>
        for &FileWriteAtResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileWriteAtResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FileWriteAtResponse)
                    .write_unaligned((self as *const FileWriteAtResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<FileWriteAtResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileWriteAtResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileWriteAtResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { actual_count: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FilesystemInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FilesystemInfo {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            96
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilesystemInfo, D>
        for &FilesystemInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FilesystemInfo>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FilesystemInfo)
                    .write_unaligned((self as *const FilesystemInfo).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u64, D>,
            T1: fidl::encoding::Encode<u64, D>,
            T2: fidl::encoding::Encode<u64, D>,
            T3: fidl::encoding::Encode<u64, D>,
            T4: fidl::encoding::Encode<u64, D>,
            T5: fidl::encoding::Encode<u64, D>,
            T6: fidl::encoding::Encode<u32, D>,
            T7: fidl::encoding::Encode<u32, D>,
            T8: fidl::encoding::Encode<u32, D>,
            T9: fidl::encoding::Encode<u32, D>,
            T10: fidl::encoding::Encode<fidl::encoding::Array<i8, 32>, D>,
        > fidl::encoding::Encode<FilesystemInfo, D>
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FilesystemInfo>(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 + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 40, depth)?;
            self.6.encode(encoder, offset + 48, depth)?;
            self.7.encode(encoder, offset + 52, depth)?;
            self.8.encode(encoder, offset + 56, depth)?;
            self.9.encode(encoder, offset + 60, depth)?;
            self.10.encode(encoder, offset + 64, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilesystemInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                total_bytes: fidl::new_empty!(u64, D),
                used_bytes: fidl::new_empty!(u64, D),
                total_nodes: fidl::new_empty!(u64, D),
                used_nodes: fidl::new_empty!(u64, D),
                free_shared_pool_bytes: fidl::new_empty!(u64, D),
                fs_id: fidl::new_empty!(u64, D),
                block_size: fidl::new_empty!(u32, D),
                max_filename_size: fidl::new_empty!(u32, D),
                fs_type: fidl::new_empty!(u32, D),
                padding: fidl::new_empty!(u32, D),
                name: fidl::new_empty!(fidl::encoding::Array<i8, 32>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 96);
            }
            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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut LinkableLinkIntoRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LinkableLinkIntoRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LinkableLinkIntoRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::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<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            LinkableLinkIntoRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for LinkableLinkIntoRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dst_parent_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                dst: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.dst_parent_token, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dst,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeAttributes {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeAttributes {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeAttributes, D>
        for &NodeAttributes
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeAttributes>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut NodeAttributes)
                    .write_unaligned((self as *const NodeAttributes).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                let padding_mask = 0xffffffff00000000u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u32, D>,
            T1: fidl::encoding::Encode<u64, D>,
            T2: fidl::encoding::Encode<u64, D>,
            T3: fidl::encoding::Encode<u64, D>,
            T4: fidl::encoding::Encode<u64, D>,
            T5: fidl::encoding::Encode<u64, D>,
            T6: fidl::encoding::Encode<u64, D>,
        > fidl::encoding::Encode<NodeAttributes, D> for (T0, T1, T2, T3, T4, T5, T6)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeAttributes>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 40, depth)?;
            self.6.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeAttributes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mode: fidl::new_empty!(u32, D),
                id: fidl::new_empty!(u64, D),
                content_size: fidl::new_empty!(u64, D),
                storage_size: fidl::new_empty!(u64, D),
                link_count: fidl::new_empty!(u64, D),
                creation_time: fidl::new_empty!(u64, D),
                modification_time: fidl::new_empty!(u64, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.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,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 56);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeAttributes2 {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeAttributes2 {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeAttributes2, D>
        for &NodeAttributes2
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeAttributes2>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeAttributes2, D>::encode(
                (
                    <MutableNodeAttributes as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.mutable_attributes,
                    ),
                    <ImmutableNodeAttributes as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.immutable_attributes,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<MutableNodeAttributes, D>,
            T1: fidl::encoding::Encode<ImmutableNodeAttributes, D>,
        > fidl::encoding::Encode<NodeAttributes2, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeAttributes2>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeAttributes2 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mutable_attributes: fidl::new_empty!(MutableNodeAttributes, D),
                immutable_attributes: fidl::new_empty!(ImmutableNodeAttributes, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                MutableNodeAttributes,
                D,
                &mut self.mutable_attributes,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ImmutableNodeAttributes,
                D,
                &mut self.immutable_attributes,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NodeCloneRequest {
        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 NodeCloneRequest {
        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<NodeCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NodeCloneRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeCloneRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <OpenFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<OpenFlags, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<NodeCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeCloneRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NodeCloneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                flags: fidl::new_empty!(OpenFlags, fidl::encoding::DefaultFuchsiaResourceDialect),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                OpenFlags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.flags,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NodeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.object,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeGetAttrResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeGetAttrResponse {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeGetAttrResponse, D>
        for &NodeGetAttrResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetAttrResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut NodeGetAttrResponse)
                    .write_unaligned((self as *const NodeGetAttrResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u64;
                let padding_mask = 0xffffffff00000000u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
                let padding_ptr = buf_ptr.offset(8) as *mut u64;
                let padding_mask = 0xffffffff00000000u64;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<i32, D>,
            T1: fidl::encoding::Encode<NodeAttributes, D>,
        > fidl::encoding::Encode<NodeGetAttrResponse, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetAttrResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeGetAttrResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D), attributes: fidl::new_empty!(NodeAttributes, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { buf_ptr.offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 64);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeGetAttributesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeGetAttributesRequest {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NodeGetAttributesRequest, D> for &NodeGetAttributesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetAttributesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeGetAttributesRequest, D>::encode(
                (<NodeAttributesQuery as fidl::encoding::ValueTypeMarker>::borrow(&self.query),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<NodeAttributesQuery, D>,
        > fidl::encoding::Encode<NodeGetAttributesRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetAttributesRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NodeGetAttributesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { query: fidl::new_empty!(NodeAttributesQuery, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for NodeGetExtendedAttributeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeGetExtendedAttributeRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NodeGetExtendedAttributeRequest, D>
        for &NodeGetExtendedAttributeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetExtendedAttributeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeGetExtendedAttributeRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.name,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 255>, D>,
        > fidl::encoding::Encode<NodeGetExtendedAttributeRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetExtendedAttributeRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NodeGetExtendedAttributeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { name: fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for NodeGetFlagsResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeGetFlagsResponse {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeGetFlagsResponse, D>
        for &NodeGetFlagsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetFlagsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeGetFlagsResponse, D>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <OpenFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<i32, D>,
            T1: fidl::encoding::Encode<OpenFlags, D>,
        > fidl::encoding::Encode<NodeGetFlagsResponse, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeGetFlagsResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeGetFlagsResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D), flags: fidl::new_empty!(OpenFlags, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(i32, D, &mut self.s, decoder, offset + 0, _depth)?;
            fidl::decode!(OpenFlags, D, &mut self.flags, 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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NodeListExtendedAttributesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeListExtendedAttributesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NodeListExtendedAttributesRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.iterator
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            NodeListExtendedAttributesRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NodeListExtendedAttributesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<ExtendedAttributeIteratorMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NodeOnOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeOnOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeOnOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<NodeInfoDeprecated>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<NodeOnOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NodeOnOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
                info: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<NodeInfoDeprecated>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                i32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.s,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::OptionalUnion<NodeInfoDeprecated>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.info,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeQueryFilesystemResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeQueryFilesystemResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NodeQueryFilesystemResponse, D> for &NodeQueryFilesystemResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeQueryFilesystemResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeQueryFilesystemResponse, D>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.s),
                    <fidl::encoding::Boxed<FilesystemInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<i32, D>,
            T1: fidl::encoding::Encode<fidl::encoding::Boxed<FilesystemInfo>, D>,
        > fidl::encoding::Encode<NodeQueryFilesystemResponse, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeQueryFilesystemResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NodeQueryFilesystemResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(i32, D),
                info: fidl::new_empty!(fidl::encoding::Boxed<FilesystemInfo>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, D, &mut self.s, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::Boxed<FilesystemInfo>,
                D,
                &mut self.info,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeRemoveExtendedAttributeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeRemoveExtendedAttributeRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NodeRemoveExtendedAttributeRequest, D>
        for &NodeRemoveExtendedAttributeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeRemoveExtendedAttributeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeRemoveExtendedAttributeRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.name,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 255>, D>,
        > fidl::encoding::Encode<NodeRemoveExtendedAttributeRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeRemoveExtendedAttributeRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NodeRemoveExtendedAttributeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { name: fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for NodeSetAttrRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeSetAttrRequest {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetAttrRequest, D>
        for &NodeSetAttrRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetAttrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeSetAttrRequest, D>::encode(
                (
                    <NodeAttributeFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
                    <NodeAttributes as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<NodeAttributeFlags, D>,
            T1: fidl::encoding::Encode<NodeAttributes, D>,
        > fidl::encoding::Encode<NodeSetAttrRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetAttrRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetAttrRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                flags: fidl::new_empty!(NodeAttributeFlags, D),
                attributes: fidl::new_empty!(NodeAttributes, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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!(NodeAttributeFlags, D, &mut self.flags, decoder, offset + 0, _depth)?;
            fidl::decode!(NodeAttributes, D, &mut self.attributes, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeSetAttrResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeSetAttrResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetAttrResponse, D>
        for &NodeSetAttrResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetAttrResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut NodeSetAttrResponse)
                    .write_unaligned((self as *const NodeSetAttrResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<NodeSetAttrResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetAttrResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetAttrResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NodeSetExtendedAttributeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetExtendedAttributeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NodeSetExtendedAttributeRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                ExtendedAttributeValue,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                SetExtendedAttributeMode,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            NodeSetExtendedAttributeRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NodeSetExtendedAttributeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::Vector<u8, 255>, fidl::encoding::DefaultFuchsiaResourceDialect),
                value: fidl::new_empty!(
                    ExtendedAttributeValue,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mode: fidl::new_empty!(
                    SetExtendedAttributeMode,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Vector<u8, 255>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.name, decoder, offset + 0, _depth)?;
            fidl::decode!(
                ExtendedAttributeValue,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.value,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                SetExtendedAttributeMode,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mode,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeSetFlagsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeSetFlagsRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetFlagsRequest, D>
        for &NodeSetFlagsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetFlagsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeSetFlagsRequest, D>::encode(
                (<OpenFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OpenFlags, D>>
        fidl::encoding::Encode<NodeSetFlagsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetFlagsRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetFlagsRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { flags: fidl::new_empty!(OpenFlags, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for NodeSetFlagsResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeSetFlagsResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetFlagsResponse, D>
        for &NodeSetFlagsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetFlagsResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut NodeSetFlagsResponse)
                    .write_unaligned((self as *const NodeSetFlagsResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<NodeSetFlagsResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetFlagsResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetFlagsResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { s: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ReadableReadRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ReadableReadRequest {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ReadableReadRequest, D>
        for &ReadableReadRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ReadableReadRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ReadableReadRequest)
                    .write_unaligned((self as *const ReadableReadRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<ReadableReadRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ReadableReadRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReadableReadRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { count: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ReadableReadResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ReadableReadResponse {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ReadableReadResponse, D>
        for &ReadableReadResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ReadableReadResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ReadableReadResponse, D>::encode(
                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.data,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
        > fidl::encoding::Encode<ReadableReadResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ReadableReadResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReadableReadResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for Service {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Service {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Service, D> for &Service {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Service>(offset);
            encoder.write_num(0u8, offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Service {
        #[inline(always)]
        fn new_empty() -> Self {
            Self
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

    impl fidl::encoding::ValueTypeMarker for SymlinkObject {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SymlinkObject {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SymlinkObject, D>
        for &SymlinkObject
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SymlinkObject>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SymlinkObject, D>::encode(
                (<fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.target,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4095>, D>,
        > fidl::encoding::Encode<SymlinkObject, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SymlinkObject>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SymlinkObject {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { target: fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for WritableWriteRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for WritableWriteRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WritableWriteRequest, D>
        for &WritableWriteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WritableWriteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<WritableWriteRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.data,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
        > fidl::encoding::Encode<WritableWriteRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WritableWriteRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WritableWriteRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for WritableWriteResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for WritableWriteResponse {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WritableWriteResponse, D>
        for &WritableWriteResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WritableWriteResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut WritableWriteResponse)
                    .write_unaligned((self as *const WritableWriteResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<WritableWriteResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WritableWriteResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WritableWriteResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { actual_count: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl AdvisoryLockRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.wait {
                return 3;
            }
            if let Some(_) = self.range {
                return 2;
            }
            if let Some(_) = self.type_ {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for AdvisoryLockRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AdvisoryLockRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvisoryLockRequest, D>
        for &AdvisoryLockRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvisoryLockRequest>(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::<AdvisoryLockType, D>(
                self.type_
                    .as_ref()
                    .map(<AdvisoryLockType 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::<AdvisoryLockRange, D>(
                self.range
                    .as_ref()
                    .map(<AdvisoryLockRange as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvisoryLockRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <AdvisoryLockType 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.type_.get_or_insert_with(|| fidl::new_empty!(AdvisoryLockType, D));
                fidl::decode!(AdvisoryLockType, D, 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 =
                    <AdvisoryLockRange 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.range.get_or_insert_with(|| fidl::new_empty!(AdvisoryLockRange, D));
                fidl::decode!(AdvisoryLockRange, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.wait.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ConnectionInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectionInfo
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

    impl fidl::encoding::ValueTypeMarker for ConnectorInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ConnectorInfo {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectorInfo, D>
        for &ConnectorInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectorInfo>(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::<NodeAttributes2, D>(
                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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectorInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <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, D));
                fidl::decode!(NodeAttributes2, D, 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 DirectoryInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.attributes {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryInfo {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DirectoryInfo, D>
        for &DirectoryInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryInfo>(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::<NodeAttributes2, D>(
                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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DirectoryInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <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, D));
                fidl::decode!(NodeAttributes2, D, 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 DirectoryProtocolOptions {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.optional_rights {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for DirectoryProtocolOptions {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DirectoryProtocolOptions {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DirectoryProtocolOptions, D> for &DirectoryProtocolOptions
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryProtocolOptions>(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, D>(
                self.optional_rights
                    .as_ref()
                    .map(<Operations as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DirectoryProtocolOptions
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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.optional_rights.get_or_insert_with(|| fidl::new_empty!(Operations, D));
                fidl::decode!(Operations, D, 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FileInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.observer.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::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<
                    fidl::Stream,
                    { fidl::ObjectType::STREAM.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.stream.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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, fidl::encoding::DefaultFuchsiaResourceDialect> for FileInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl ImmutableNodeAttributes {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.verity_enabled {
                return 10;
            }
            if let Some(_) = self.root_hash {
                return 9;
            }
            if let Some(_) = self.options {
                return 8;
            }
            if let Some(_) = self.change_time {
                return 7;
            }
            if let Some(_) = self.id {
                return 6;
            }
            if let Some(_) = self.link_count {
                return 5;
            }
            if let Some(_) = self.storage_size {
                return 4;
            }
            if let Some(_) = self.content_size {
                return 3;
            }
            if let Some(_) = self.abilities {
                return 2;
            }
            if let Some(_) = self.protocols {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ImmutableNodeAttributes {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ImmutableNodeAttributes {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ImmutableNodeAttributes, D> for &ImmutableNodeAttributes
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImmutableNodeAttributes>(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::<NodeProtocolKinds, D>(
                self.protocols
                    .as_ref()
                    .map(<NodeProtocolKinds 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::<Operations, D>(
                self.abilities
                    .as_ref()
                    .map(<Operations as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > 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 = (8 - 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::<VerificationOptions, D>(
                self.options
                    .as_ref()
                    .map(<VerificationOptions as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 9 > 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 = (9 - 1) * envelope_size;

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

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

            _prev_end_offset = cur_offset + envelope_size;
            if 10 > 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 = (10 - 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, D>(
                self.verity_enabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ImmutableNodeAttributes
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <NodeProtocolKinds 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.protocols.get_or_insert_with(|| fidl::new_empty!(NodeProtocolKinds, D));
                fidl::decode!(NodeProtocolKinds, D, 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 =
                    <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.abilities.get_or_insert_with(|| fidl::new_empty!(Operations, D));
                fidl::decode!(Operations, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.change_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 8 {
                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 =
                    <VerificationOptions 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.options.get_or_insert_with(|| fidl::new_empty!(VerificationOptions, D));
                fidl::decode!(VerificationOptions, D, 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 < 9 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Vector<u8, 64> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .root_hash
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 64>, D));
                fidl::decode!(fidl::encoding::Vector<u8, 64>, D, 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 < 10 {
                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.verity_enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 MutableNodeAttributes {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.wrapping_key_id {
                return 10;
            }
            if let Some(_) = self.selinux_context {
                return 9;
            }
            if let Some(_) = self.casefold {
                return 8;
            }
            if let Some(_) = self.access_time {
                return 7;
            }
            if let Some(_) = self.rdev {
                return 6;
            }
            if let Some(_) = self.gid {
                return 5;
            }
            if let Some(_) = self.uid {
                return 4;
            }
            if let Some(_) = self.mode {
                return 3;
            }
            if let Some(_) = self.modification_time {
                return 2;
            }
            if let Some(_) = self.creation_time {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for MutableNodeAttributes {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > 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 = (8 - 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, D>(
                self.casefold.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 9 > 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 = (9 - 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::<SelinuxContext, D>(
                self.selinux_context
                    .as_ref()
                    .map(<SelinuxContext as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 10 > 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 = (10 - 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::Array<u8, 16>, D>(
                self.wrapping_key_id.as_ref().map(
                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MutableNodeAttributes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.access_time.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 8 {
                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.casefold.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 9 {
                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 =
                    <SelinuxContext 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.selinux_context.get_or_insert_with(|| fidl::new_empty!(SelinuxContext, D));
                fidl::decode!(SelinuxContext, D, 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 < 10 {
                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::Array<u8, 16> 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
                    .wrapping_key_id
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
                fidl::decode!(fidl::encoding::Array<u8, 16>, D, 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 NodeOptions {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.create_attributes {
                return 6;
            }
            if let Some(_) = self.attributes {
                return 5;
            }
            if let Some(_) = self.rights {
                return 4;
            }
            if let Some(_) = self.mode {
                return 3;
            }
            if let Some(_) = self.protocols {
                return 2;
            }
            if let Some(_) = self.flags {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeOptions {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeOptions {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeOptions, D>
        for &NodeOptions
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeOptions>(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::<NodeFlags, D>(
                self.flags.as_ref().map(<NodeFlags 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::<NodeProtocols, D>(
                self.protocols
                    .as_ref()
                    .map(<NodeProtocols as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeOptions {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <NodeFlags 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.flags.get_or_insert_with(|| fidl::new_empty!(NodeFlags, D));
                fidl::decode!(NodeFlags, D, 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 =
                    <NodeProtocols 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.protocols.get_or_insert_with(|| fidl::new_empty!(NodeProtocols, D));
                fidl::decode!(NodeProtocols, D, 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 =
                    <CreationMode 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.mode.get_or_insert_with(|| fidl::new_empty!(CreationMode, D));
                fidl::decode!(CreationMode, D, 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 =
                    <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, D));
                fidl::decode!(Operations, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <MutableNodeAttributes 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
                    .create_attributes
                    .get_or_insert_with(|| fidl::new_empty!(MutableNodeAttributes, D));
                fidl::decode!(
                    MutableNodeAttributes,
                    D,
                    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 NodeProtocols {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.node {
                return 4;
            }
            if let Some(_) = self.symlink {
                return 3;
            }
            if let Some(_) = self.file {
                return 2;
            }
            if let Some(_) = self.directory {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeProtocols {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NodeProtocols {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProtocols, D>
        for &NodeProtocols
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeProtocols>(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::<DirectoryProtocolOptions, D>(
                self.directory
                    .as_ref()
                    .map(<DirectoryProtocolOptions 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::<FileProtocolFlags, D>(
                self.file
                    .as_ref()
                    .map(<FileProtocolFlags as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProtocols {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <DirectoryProtocolOptions 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
                    .directory
                    .get_or_insert_with(|| fidl::new_empty!(DirectoryProtocolOptions, D));
                fidl::decode!(
                    DirectoryProtocolOptions,
                    D,
                    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 =
                    <FileProtocolFlags 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.file.get_or_insert_with(|| fidl::new_empty!(FileProtocolFlags, D));
                fidl::decode!(FileProtocolFlags, D, 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 =
                    <SymlinkProtocolFlags 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.symlink.get_or_insert_with(|| fidl::new_empty!(SymlinkProtocolFlags, D));
                fidl::decode!(
                    SymlinkProtocolFlags,
                    D,
                    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 =
                    <NodeProtocolFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.node.get_or_insert_with(|| fidl::new_empty!(NodeProtocolFlags, D));
                fidl::decode!(NodeProtocolFlags, D, 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 Options {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.create_attributes {
                return 2;
            }
            if let Some(_) = self.attributes {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for Options {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Options {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Options>(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::<NodeAttributesQuery, D>(
                self.attributes
                    .as_ref()
                    .map(<NodeAttributesQuery 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::<MutableNodeAttributes, D>(
                self.create_attributes
                    .as_ref()
                    .map(<MutableNodeAttributes as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <NodeAttributesQuery 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!(NodeAttributesQuery, D));
                fidl::decode!(NodeAttributesQuery, D, 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 =
                    <MutableNodeAttributes 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
                    .create_attributes
                    .get_or_insert_with(|| fidl::new_empty!(MutableNodeAttributes, D));
                fidl::decode!(
                    MutableNodeAttributes,
                    D,
                    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 SymlinkInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.attributes {
                return 2;
            }
            if let Some(_) = self.target {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for SymlinkInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4095>, D>(
                self.target.as_ref().map(
                    <fidl::encoding::Vector<u8, 4095> 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::<NodeAttributes2, D>(
                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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SymlinkInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Vector<u8, 4095> 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
                    .target
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D));
                fidl::decode!(fidl::encoding::Vector<u8, 4095>, D, 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 =
                    <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, D));
                fidl::decode!(NodeAttributes2, D, 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 UnlinkOptions {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.flags {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UnlinkOptions {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnlinkOptions {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnlinkOptions, D>
        for &UnlinkOptions
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnlinkOptions>(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::<UnlinkFlags, D>(
                self.flags.as_ref().map(<UnlinkFlags as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnlinkOptions {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <UnlinkFlags 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.flags.get_or_insert_with(|| fidl::new_empty!(UnlinkFlags, D));
                fidl::decode!(UnlinkFlags, D, 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 VerificationOptions {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.salt {
                return 2;
            }
            if let Some(_) = self.hash_algorithm {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for VerificationOptions {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VerificationOptions {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VerificationOptions, D>
        for &VerificationOptions
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VerificationOptions>(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::<HashAlgorithm, D>(
                self.hash_algorithm
                    .as_ref()
                    .map(<HashAlgorithm as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VerificationOptions {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <HashAlgorithm 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.hash_algorithm.get_or_insert_with(|| fidl::new_empty!(HashAlgorithm, D));
                fidl::decode!(HashAlgorithm, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Vector<u8, 32> 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
                    .salt
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, 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::ValueTypeMarker for ConnectionProtocols {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ConnectionProtocols {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionProtocols, D>
        for &ConnectionProtocols
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectionProtocols>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ConnectionProtocols::Connector(ref val) => {
                    fidl::encoding::encode_in_envelope::<ConnectorFlags, D>(
                        <ConnectorFlags as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ConnectionProtocols::Node(ref val) => {
                    fidl::encoding::encode_in_envelope::<NodeOptions, D>(
                        <NodeOptions as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ConnectionProtocols::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionProtocols {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <ConnectorFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <NodeOptions 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 ConnectionProtocols::Connector(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ConnectionProtocols::Connector(fidl::new_empty!(ConnectorFlags, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ConnectionProtocols::Connector(ref mut val) = self {
                        fidl::decode!(ConnectorFlags, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ConnectionProtocols::Node(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ConnectionProtocols::Node(fidl::new_empty!(NodeOptions, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ConnectionProtocols::Node(ref mut val) = self {
                        fidl::decode!(NodeOptions, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = ConnectionProtocols::__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 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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ExtendedAttributeValue
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <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<
                            fidl::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fidl::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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ExtendedAttributeValue
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[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<
                    fidl::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>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Bytes(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<u8, 32768>, fidl::encoding::DefaultFuchsiaResourceDialect, 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<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ExtendedAttributeValue::Buffer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NodeInfoDeprecated
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeInfoDeprecated>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                NodeInfoDeprecated::Service(ref val) => fidl::encoding::encode_in_envelope::<
                    Service,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::File(ref mut val) => fidl::encoding::encode_in_envelope::<
                    FileObject,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <FileObject as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::Directory(ref val) => fidl::encoding::encode_in_envelope::<
                    DirectoryObject,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <DirectoryObject as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NodeInfoDeprecated::Symlink(ref val) => fidl::encoding::encode_in_envelope::<
                    SymlinkObject,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SymlinkObject as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NodeInfoDeprecated
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Service(fidl::new_empty!(Service, fidl::encoding::DefaultFuchsiaResourceDialect))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Service(ref mut val) = self {
                        fidl::decode!(
                            Service,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::File(ref mut val) = self {
                        fidl::decode!(
                            FileObject,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Directory(ref mut val) = self {
                        fidl::decode!(
                            DirectoryObject,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NodeInfoDeprecated::Symlink(ref mut val) = self {
                        fidl::decode!(
                            SymlinkObject,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Representation
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Representation>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                Representation::Connector(ref val) => fidl::encoding::encode_in_envelope::<
                    ConnectorInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ConnectorInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::Directory(ref val) => fidl::encoding::encode_in_envelope::<
                    DirectoryInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <DirectoryInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::File(ref mut val) => fidl::encoding::encode_in_envelope::<
                    FileInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <FileInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::Symlink(ref val) => fidl::encoding::encode_in_envelope::<
                    SymlinkInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SymlinkInfo as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Representation::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for Representation
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[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 => <ConnectorInfo 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::Connector(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Representation::Connector(fidl::new_empty!(
                            ConnectorInfo,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Connector(ref mut val) = self {
                        fidl::decode!(
                            ConnectorInfo,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Directory(ref mut val) = self {
                        fidl::decode!(
                            DirectoryInfo,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::File(ref mut val) = self {
                        fidl::decode!(
                            FileInfo,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Representation::Symlink(ref mut val) = self {
                        fidl::decode!(
                            SymlinkInfo,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for SelinuxContext {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SelinuxContext {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SelinuxContext, D>
        for &SelinuxContext
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SelinuxContext>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                SelinuxContext::Data(ref val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::Vector<u8, 256>,
                    D,
                >(
                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SelinuxContext::UseExtendedAttributes(ref val) => {
                    fidl::encoding::encode_in_envelope::<EmptyStruct, D>(
                        <EmptyStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                SelinuxContext::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SelinuxContext {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, 256> as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <EmptyStruct 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 SelinuxContext::Data(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SelinuxContext::Data(
                            fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SelinuxContext::Data(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SelinuxContext::UseExtendedAttributes(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            SelinuxContext::UseExtendedAttributes(fidl::new_empty!(EmptyStruct, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SelinuxContext::UseExtendedAttributes(ref mut val) = self {
                        fidl::decode!(EmptyStruct, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = SelinuxContext::__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(())
        }
    }
}