fidl_next_fuchsia_io/

fidl_next_fuchsia_io.rs

// DO NOT EDIT: This file is machine-generated by fidlgen
#![warn(clippy::all)]
#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]

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

    }
}

impl ::fidl_next::Encodable for Operations {
    type Encoded = WireOperations;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Operations
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOperations { value } = out);
        let _ = value.write(::fidl_next::WireU64::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireOperations> for Operations {
    fn from(wire: WireOperations) -> Self {
        Self::from_bits_retain(u64::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireOperations> for Operations {
    #[inline]
    fn take_from(from: &WireOperations) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`Operations`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireOperations {
    value: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireOperations {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOperations
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u64::from(*value);
        if set & !Operations::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: Operations::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<Operations> for WireOperations {
    fn from(natural: Operations) -> Self {
        Self { value: ::fidl_next::WireU64::from(natural.bits()) }
    }
}

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

/// The wire type corresponding to [`Abilities`].
pub type WireAbilities = crate::WireOperations;

#[doc = " The reference point for updating the seek offset. See [`File.Seek`].\n\n This enum matches the `zx_stream_seek_origin_t` enum.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum SeekOrigin {
    Start = 0,
    Current = 1,
    End = 2,
}

impl ::fidl_next::Encodable for SeekOrigin {
    type Encoded = WireSeekOrigin;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SeekOrigin
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSeekOrigin { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Start => 0,

            Self::Current => 1,

            Self::End => 2,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireSeekOrigin> for SeekOrigin {
    fn from(wire: WireSeekOrigin) -> Self {
        match u32::from(wire.value) {
            0 => Self::Start,

            1 => Self::Current,

            2 => Self::End,

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireSeekOrigin> for SeekOrigin {
    #[inline]
    fn take_from(from: &WireSeekOrigin) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`SeekOrigin`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireSeekOrigin {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireSeekOrigin {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireSeekOrigin {
    pub const START: WireSeekOrigin = WireSeekOrigin { value: ::fidl_next::WireU32(0) };

    pub const CURRENT: WireSeekOrigin = WireSeekOrigin { value: ::fidl_next::WireU32(1) };

    pub const END: WireSeekOrigin = WireSeekOrigin { value: ::fidl_next::WireU32(2) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSeekOrigin
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);

        match u32::from(*value) {
            0 | 1 | 2 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

impl ::core::convert::From<SeekOrigin> for WireSeekOrigin {
    fn from(natural: SeekOrigin) -> Self {
        match natural {
            SeekOrigin::Start => WireSeekOrigin::START,

            SeekOrigin::Current => WireSeekOrigin::CURRENT,

            SeekOrigin::End => WireSeekOrigin::END,
        }
    }
}

#[derive(Clone, Debug)]
pub struct AdvisoryLockRange {
    pub origin: crate::SeekOrigin,

    pub offset: i64,

    pub length: i64,
}

impl ::fidl_next::Encodable for AdvisoryLockRange {
    type Encoded = WireAdvisoryLockRange;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AdvisoryLockRange
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                origin,
                offset,
                length,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.origin, encoder, origin)?;

        ::fidl_next::Encode::encode(&mut self.offset, encoder, offset)?;

        ::fidl_next::Encode::encode(&mut self.length, encoder, length)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<AdvisoryLockRange> {
    type EncodedOption = ::fidl_next::WireBox<WireAdvisoryLockRange>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<AdvisoryLockRange>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockRange: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireAdvisoryLockRange> for AdvisoryLockRange {
    #[inline]
    fn take_from(from: &WireAdvisoryLockRange) -> Self {
        Self {
            origin: ::fidl_next::TakeFrom::take_from(&from.origin),

            offset: ::fidl_next::TakeFrom::take_from(&from.offset),

            length: ::fidl_next::TakeFrom::take_from(&from.length),
        }
    }
}

/// The wire type corresponding to [`AdvisoryLockRange`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireAdvisoryLockRange {
    pub origin: crate::WireSeekOrigin,

    pub offset: ::fidl_next::WireI64,

    pub length: ::fidl_next::WireI64,
}

unsafe impl ::fidl_next::ZeroPadding for WireAdvisoryLockRange {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAdvisoryLockRange
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut origin,
                mut offset,
                mut length,

            } = slot;
        }

        ::fidl_next::Decode::decode(origin.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(offset.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(length.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum AdvisoryLockType {
    Read = 1,
    Write = 2,
    Unlock = 3,
}

impl ::fidl_next::Encodable for AdvisoryLockType {
    type Encoded = WireAdvisoryLockType;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AdvisoryLockType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireAdvisoryLockType { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Read => 1,

            Self::Write => 2,

            Self::Unlock => 3,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireAdvisoryLockType> for AdvisoryLockType {
    fn from(wire: WireAdvisoryLockType) -> Self {
        match u32::from(wire.value) {
            1 => Self::Read,

            2 => Self::Write,

            3 => Self::Unlock,

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireAdvisoryLockType> for AdvisoryLockType {
    #[inline]
    fn take_from(from: &WireAdvisoryLockType) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`AdvisoryLockType`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireAdvisoryLockType {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireAdvisoryLockType {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireAdvisoryLockType {
    pub const READ: WireAdvisoryLockType = WireAdvisoryLockType { value: ::fidl_next::WireU32(1) };

    pub const WRITE: WireAdvisoryLockType = WireAdvisoryLockType { value: ::fidl_next::WireU32(2) };

    pub const UNLOCK: WireAdvisoryLockType =
        WireAdvisoryLockType { value: ::fidl_next::WireU32(3) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAdvisoryLockType
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);

        match u32::from(*value) {
            1 | 2 | 3 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

impl ::core::convert::From<AdvisoryLockType> for WireAdvisoryLockType {
    fn from(natural: AdvisoryLockType) -> Self {
        match natural {
            AdvisoryLockType::Read => WireAdvisoryLockType::READ,

            AdvisoryLockType::Write => WireAdvisoryLockType::WRITE,

            AdvisoryLockType::Unlock => WireAdvisoryLockType::UNLOCK,
        }
    }
}

#[derive(Clone, Debug)]
pub struct AdvisoryLockRequest {
    pub type_: Option<crate::AdvisoryLockType>,

    pub range: Option<crate::AdvisoryLockRange>,

    pub wait: Option<bool>,
}

impl AdvisoryLockRequest {
    fn __max_ordinal(&self) -> usize {
        if self.type_.is_some() {
            return 1;
        }

        if self.range.is_some() {
            return 2;
        }

        if self.wait.is_some() {
            return 3;
        }

        0
    }
}

impl ::fidl_next::Encodable for AdvisoryLockRequest {
    type Encoded = WireAdvisoryLockRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AdvisoryLockRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireAdvisoryLockRequest { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(wait) = &mut self.wait {
                        ::fidl_next::WireEnvelope::encode_value(
                            wait,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(range) = &mut self.range {
                        ::fidl_next::WireEnvelope::encode_value(
                            range,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(type_) = &mut self.type_ {
                        ::fidl_next::WireEnvelope::encode_value(
                            type_,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireAdvisoryLockRequest> for AdvisoryLockRequest {
    #[inline]
    fn take_from(from: &WireAdvisoryLockRequest) -> Self {
        Self {
            type_: from.type_().map(::fidl_next::TakeFrom::take_from),

            range: from.range().map(::fidl_next::TakeFrom::take_from),

            wait: from.wait().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`AdvisoryLockRequest`].
#[repr(C)]
pub struct WireAdvisoryLockRequest {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireAdvisoryLockRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAdvisoryLockRequest
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAdvisoryLockType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAdvisoryLockRange>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireAdvisoryLockRequest {
    pub fn type_(&self) -> Option<&crate::WireAdvisoryLockType> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn range(&self) -> Option<&crate::WireAdvisoryLockRange> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn wait(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireAdvisoryLockRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("AdvisoryLockRequest")
            .field("type_", &self.type_())
            .field("range", &self.range())
            .field("wait", &self.wait())
            .finish()
    }
}

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

impl ::fidl_next::Encodable for AdvisoryLockingAdvisoryLockRequest {
    type Encoded = WireAdvisoryLockingAdvisoryLockRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AdvisoryLockingAdvisoryLockRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                request,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.request, encoder, request)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<AdvisoryLockingAdvisoryLockRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireAdvisoryLockingAdvisoryLockRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<AdvisoryLockingAdvisoryLockRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockingAdvisoryLockRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireAdvisoryLockingAdvisoryLockRequest>
    for AdvisoryLockingAdvisoryLockRequest
{
    #[inline]
    fn take_from(from: &WireAdvisoryLockingAdvisoryLockRequest) -> Self {
        Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
    }
}

/// The wire type corresponding to [`AdvisoryLockingAdvisoryLockRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireAdvisoryLockingAdvisoryLockRequest {
    pub request: crate::WireAdvisoryLockRequest,
}

unsafe impl ::fidl_next::ZeroPadding for WireAdvisoryLockingAdvisoryLockRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAdvisoryLockingAdvisoryLockRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut request,

            } = slot;
        }

        ::fidl_next::Decode::decode(request.as_mut(), decoder)?;

        Ok(())
    }
}

pub type AdvisoryLockingAdvisoryLockResponse = ();

/// The wire type corresponding to [`AdvisoryLockingAdvisoryLockResponse`].
pub type WireAdvisoryLockingAdvisoryLockResponse = ();

/// The type corresponding to the AdvisoryLocking protocol.
#[doc = " Advisory locking protocol.\n\n This protocol is intended to be composed into the |File| protocol to\n provide support for advisory locking.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n These primitives are designed to support the flock() and fcntl(),\n specifically F_SETLK, F_SETLKW, and F_GETLK, functionality that code\n running on Fuchsia expects from other operating systems.\n"]
#[derive(Debug)]
pub struct AdvisoryLocking;

pub mod advisory_locking {
    pub mod prelude {
        pub use crate::{
            advisory_locking, AdvisoryLocking, AdvisoryLockingClientHandler,
            AdvisoryLockingClientSender, AdvisoryLockingServerHandler, AdvisoryLockingServerSender,
        };

        pub use crate::AdvisoryLockingAdvisoryLockRequest;

        pub use crate::AdvisoryLockingAdvisoryLockResponse;
    }

    pub struct AdvisoryLock;

    impl ::fidl_next::Method for AdvisoryLock {
        const ORDINAL: u64 = 7992130864415541162;

        type Protocol = crate::AdvisoryLocking;

        type Request = crate::WireAdvisoryLockingAdvisoryLockRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireAdvisoryLockingAdvisoryLockResponse,
            ::fidl_next::WireI32,
        >;
    }
}

/// A helper trait for the `AdvisoryLocking` client sender.
pub trait AdvisoryLockingClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, advisory_locking::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >;
}

impl<___T> AdvisoryLockingClientSender for ::fidl_next::ClientSender<___T, AdvisoryLocking>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, advisory_locking::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7992130864415541162, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the AdvisoryLocking protocol.
///
/// See [`AdvisoryLocking`] for more details.
pub trait AdvisoryLockingClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for AdvisoryLocking
where
    ___T: ::fidl_next::Transport,
    ___H: AdvisoryLockingClientHandler<___T>,

    <advisory_locking::AdvisoryLock as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `AdvisoryLocking` server sender.
pub trait AdvisoryLockingServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> AdvisoryLockingServerSender for ::fidl_next::ServerSender<___T, AdvisoryLocking>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the AdvisoryLocking protocol.
///
/// See [`AdvisoryLocking`] for more details.
pub trait AdvisoryLockingServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, AdvisoryLocking>,

        request: ::fidl_next::RequestBuffer<___T, advisory_locking::AdvisoryLock>,

        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for AdvisoryLocking
where
    ___T: ::fidl_next::Transport,
    ___H: AdvisoryLockingServerHandler<___T>,

    crate::WireAdvisoryLockingAdvisoryLockRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            7992130864415541162 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.advisory_lock(sender, buffer, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

::fidl_next::bitflags! {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        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;
        const _ = !0;
    }
}

impl ::fidl_next::Encodable for AllocateMode {
    type Encoded = WireAllocateMode;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AllocateMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireAllocateMode { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireAllocateMode> for AllocateMode {
    fn from(wire: WireAllocateMode) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireAllocateMode> for AllocateMode {
    #[inline]
    fn take_from(from: &WireAllocateMode) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`AllocateMode`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireAllocateMode {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireAllocateMode {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAllocateMode
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<AllocateMode> for WireAllocateMode {
    fn from(natural: AllocateMode) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

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

/// The wire type corresponding to [`Rights`].
pub type WireRights = crate::WireOperations;

#[derive(Debug)]
pub struct ConnectionInfo {
    pub rights: Option<crate::Operations>,
}

impl ConnectionInfo {
    fn __max_ordinal(&self) -> usize {
        if self.rights.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConnectionInfo {
    type Encoded = WireConnectionInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectionInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConnectionInfo { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(rights) = &mut self.rights {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConnectionInfo> for ConnectionInfo {
    #[inline]
    fn take_from(from: &WireConnectionInfo) -> Self {
        Self { rights: from.rights().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`ConnectionInfo`].
#[repr(C)]
pub struct WireConnectionInfo {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireConnectionInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnectionInfo
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireOperations>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireConnectionInfo {
    pub fn rights(&self) -> Option<&crate::WireOperations> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireConnectionInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
    }
}

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

/// The wire type corresponding to [`Id`].
pub type WireId = ::fidl_next::WireU64;

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

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

    }
}

impl ::fidl_next::Encodable for OpenFlags {
    type Encoded = WireOpenFlags;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OpenFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOpenFlags { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireOpenFlags> for OpenFlags {
    fn from(wire: WireOpenFlags) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireOpenFlags> for OpenFlags {
    #[inline]
    fn take_from(from: &WireOpenFlags) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`OpenFlags`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireOpenFlags {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireOpenFlags {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOpenFlags
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !OpenFlags::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: OpenFlags::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<OpenFlags> for WireOpenFlags {
    fn from(natural: OpenFlags) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[doc = " NodeAttributes defines generic information about a filesystem node.\n"]
#[derive(Clone, Debug)]
pub struct NodeAttributes {
    pub mode: u32,

    pub id: u64,

    pub content_size: u64,

    pub storage_size: u64,

    pub link_count: u64,

    pub creation_time: u64,

    pub modification_time: u64,
}

impl ::fidl_next::Encodable for NodeAttributes {
    type Encoded = WireNodeAttributes;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAttributes
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                mode,
                id,
                content_size,
                storage_size,
                link_count,
                creation_time,
                modification_time,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.mode, encoder, mode)?;

        ::fidl_next::Encode::encode(&mut self.id, encoder, id)?;

        ::fidl_next::Encode::encode(&mut self.content_size, encoder, content_size)?;

        ::fidl_next::Encode::encode(&mut self.storage_size, encoder, storage_size)?;

        ::fidl_next::Encode::encode(&mut self.link_count, encoder, link_count)?;

        ::fidl_next::Encode::encode(&mut self.creation_time, encoder, creation_time)?;

        ::fidl_next::Encode::encode(&mut self.modification_time, encoder, modification_time)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeAttributes> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeAttributes>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeAttributes>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeAttributes> for NodeAttributes {
    #[inline]
    fn take_from(from: &WireNodeAttributes) -> Self {
        Self {
            mode: ::fidl_next::TakeFrom::take_from(&from.mode),

            id: ::fidl_next::TakeFrom::take_from(&from.id),

            content_size: ::fidl_next::TakeFrom::take_from(&from.content_size),

            storage_size: ::fidl_next::TakeFrom::take_from(&from.storage_size),

            link_count: ::fidl_next::TakeFrom::take_from(&from.link_count),

            creation_time: ::fidl_next::TakeFrom::take_from(&from.creation_time),

            modification_time: ::fidl_next::TakeFrom::take_from(&from.modification_time),
        }
    }
}

/// The wire type corresponding to [`NodeAttributes`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeAttributes {
    pub mode: ::fidl_next::WireU32,

    pub id: ::fidl_next::WireU64,

    pub content_size: ::fidl_next::WireU64,

    pub storage_size: ::fidl_next::WireU64,

    pub link_count: ::fidl_next::WireU64,

    pub creation_time: ::fidl_next::WireU64,

    pub modification_time: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeAttributes {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAttributes
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut mode,
                mut id,
                mut content_size,
                mut storage_size,
                mut link_count,
                mut creation_time,
                mut modification_time,

            } = slot;
        }

        ::fidl_next::Decode::decode(mode.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(id.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(content_size.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(storage_size.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(link_count.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(creation_time.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(modification_time.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct NodeGetAttrResponse {
    pub s: i32,

    pub attributes: crate::NodeAttributes,
}

impl ::fidl_next::Encodable for NodeGetAttrResponse {
    type Encoded = WireNodeGetAttrResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeGetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                attributes,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.attributes, encoder, attributes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeGetAttrResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeGetAttrResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeGetAttrResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetAttrResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeGetAttrResponse> for NodeGetAttrResponse {
    #[inline]
    fn take_from(from: &WireNodeGetAttrResponse) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),
        }
    }
}

/// The wire type corresponding to [`NodeGetAttrResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeGetAttrResponse {
    pub s: ::fidl_next::WireI32,

    pub attributes: crate::WireNodeAttributes,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeGetAttrResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeGetAttrResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut attributes,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(attributes.as_mut(), decoder)?;

        Ok(())
    }
}

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

    }
}

impl ::fidl_next::Encodable for NodeAttributeFlags {
    type Encoded = WireNodeAttributeFlags;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAttributeFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeAttributeFlags { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireNodeAttributeFlags> for NodeAttributeFlags {
    fn from(wire: WireNodeAttributeFlags) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireNodeAttributeFlags> for NodeAttributeFlags {
    #[inline]
    fn take_from(from: &WireNodeAttributeFlags) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`NodeAttributeFlags`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireNodeAttributeFlags {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeAttributeFlags {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAttributeFlags
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !NodeAttributeFlags::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: NodeAttributeFlags::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<NodeAttributeFlags> for WireNodeAttributeFlags {
    fn from(natural: NodeAttributeFlags) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[derive(Clone, Debug)]
pub struct NodeSetAttrRequest {
    pub flags: crate::NodeAttributeFlags,

    pub attributes: crate::NodeAttributes,
}

impl ::fidl_next::Encodable for NodeSetAttrRequest {
    type Encoded = WireNodeSetAttrRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeSetAttrRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,
                attributes,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        ::fidl_next::Encode::encode(&mut self.attributes, encoder, attributes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeSetAttrRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeSetAttrRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeSetAttrRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetAttrRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeSetAttrRequest> for NodeSetAttrRequest {
    #[inline]
    fn take_from(from: &WireNodeSetAttrRequest) -> Self {
        Self {
            flags: ::fidl_next::TakeFrom::take_from(&from.flags),

            attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),
        }
    }
}

/// The wire type corresponding to [`NodeSetAttrRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeSetAttrRequest {
    pub flags: crate::WireNodeAttributeFlags,

    pub attributes: crate::WireNodeAttributes,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeSetAttrRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeSetAttrRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,
                mut attributes,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(attributes.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeSetAttrResponse {
    pub s: i32,
}

impl ::fidl_next::Encodable for NodeSetAttrResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeSetAttrResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeSetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeSetAttrResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeSetAttrResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeSetAttrResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetAttrResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeSetAttrResponse> for NodeSetAttrResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeSetAttrResponse) -> Self {
        Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
    }
}

/// The wire type corresponding to [`NodeSetAttrResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeSetAttrResponse {
    pub s: ::fidl_next::WireI32,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeSetAttrResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeSetAttrResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct NodeQueryFilesystemResponse {
    pub s: i32,

    pub info: Option<Box<crate::FilesystemInfo>>,
}

impl ::fidl_next::Encodable for NodeQueryFilesystemResponse {
    type Encoded = WireNodeQueryFilesystemResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeQueryFilesystemResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                info,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.info, encoder, info)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeQueryFilesystemResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeQueryFilesystemResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeQueryFilesystemResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeQueryFilesystemResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeQueryFilesystemResponse> for NodeQueryFilesystemResponse {
    #[inline]
    fn take_from(from: &WireNodeQueryFilesystemResponse) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            info: ::fidl_next::TakeFrom::take_from(&from.info),
        }
    }
}

/// The wire type corresponding to [`NodeQueryFilesystemResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeQueryFilesystemResponse {
    pub s: ::fidl_next::WireI32,

    pub info: ::fidl_next::WireBox<crate::WireFilesystemInfo>,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeQueryFilesystemResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeQueryFilesystemResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut info,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(info.as_mut(), decoder)?;

        Ok(())
    }
}

pub type NodeUpdateAttributesResponse = ();

/// The wire type corresponding to [`NodeUpdateAttributesResponse`].
pub type WireNodeUpdateAttributesResponse = ();

pub type NodeSyncResponse = ();

/// The wire type corresponding to [`NodeSyncResponse`].
pub type WireNodeSyncResponse = ();

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

    }
}

impl ::fidl_next::Encodable for ModeType {
    type Encoded = WireModeType;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ModeType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireModeType { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireModeType> for ModeType {
    fn from(wire: WireModeType) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireModeType> for ModeType {
    #[inline]
    fn take_from(from: &WireModeType) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`ModeType`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireModeType {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireModeType {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireModeType
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !ModeType::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: ModeType::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<ModeType> for WireModeType {
    fn from(natural: ModeType) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[doc = " The maximum length, in bytes, of a filesystem path.\n"]
pub const MAX_PATH_LENGTH: u64 = 4095;

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

/// The wire type corresponding to [`Path`].
pub type WirePath = ::fidl_next::WireString;

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryReadDirentsRequest {
    pub max_bytes: u64,
}

impl ::fidl_next::Encodable for DirectoryReadDirentsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireDirectoryReadDirentsRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryReadDirentsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                max_bytes,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.max_bytes, encoder, max_bytes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryReadDirentsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryReadDirentsRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryReadDirentsRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryReadDirentsRequest> for DirectoryReadDirentsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryReadDirentsRequest) -> Self {
        Self { max_bytes: ::fidl_next::TakeFrom::take_from(&from.max_bytes) }
    }
}

/// The wire type corresponding to [`DirectoryReadDirentsRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDirectoryReadDirentsRequest {
    pub max_bytes: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryReadDirentsRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryReadDirentsRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut max_bytes,

            } = slot;
        }

        ::fidl_next::Decode::decode(max_bytes.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " The maximal buffer size which can be transmitted for buffered operations.\n This capacity is currently set somewhat arbitrarily.\n"]
pub const MAX_BUF: u64 = 8192;

#[derive(Clone, Debug)]
pub struct DirectoryReadDirentsResponse {
    pub s: i32,

    pub dirents: Vec<u8>,
}

impl ::fidl_next::Encodable for DirectoryReadDirentsResponse {
    type Encoded = WireDirectoryReadDirentsResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryReadDirentsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                dirents,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.dirents, encoder, dirents)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryReadDirentsResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryReadDirentsResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryReadDirentsResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryReadDirentsResponse> for DirectoryReadDirentsResponse {
    #[inline]
    fn take_from(from: &WireDirectoryReadDirentsResponse) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            dirents: ::fidl_next::TakeFrom::take_from(&from.dirents),
        }
    }
}

/// The wire type corresponding to [`DirectoryReadDirentsResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryReadDirentsResponse {
    pub s: ::fidl_next::WireI32,

    pub dirents: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryReadDirentsResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryReadDirentsResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut dirents,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(dirents.as_mut(), decoder)?;

        let dirents = unsafe { dirents.deref_unchecked() };

        if dirents.len() > 8192 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: dirents.len() as u64,
                limit: 8192,
            });
        }

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryRewindResponse {
    pub s: i32,
}

impl ::fidl_next::Encodable for DirectoryRewindResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireDirectoryRewindResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRewindResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryRewindResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryRewindResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryRewindResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryRewindResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryRewindResponse> for DirectoryRewindResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryRewindResponse) -> Self {
        Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
    }
}

/// The wire type corresponding to [`DirectoryRewindResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDirectoryRewindResponse {
    pub s: ::fidl_next::WireI32,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryRewindResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryRewindResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirectoryGetTokenResponse {
    pub s: i32,

    pub token: Option<::fidl_next::fuchsia::zx::Handle>,
}

impl ::fidl_next::Encodable for DirectoryGetTokenResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    i32 as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireDirectoryGetTokenResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryGetTokenResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                token,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.token, encoder, token)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryGetTokenResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryGetTokenResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryGetTokenResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryGetTokenResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryGetTokenResponse> for DirectoryGetTokenResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    i32 as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryGetTokenResponse) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            token: ::fidl_next::TakeFrom::take_from(&from.token),
        }
    }
}

/// The wire type corresponding to [`DirectoryGetTokenResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryGetTokenResponse {
    pub s: ::fidl_next::WireI32,

    pub token: ::fidl_next::fuchsia::WireOptionalHandle,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryGetTokenResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryGetTokenResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut token,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(token.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
pub const MAX_NAME_LENGTH: u64 = 255;

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

/// The wire type corresponding to [`Name`].
pub type WireName = ::fidl_next::WireString;

#[derive(Debug)]
pub struct DirectoryLinkRequest {
    pub src: String,

    pub dst_parent_token: ::fidl_next::fuchsia::zx::Handle,

    pub dst: String,
}

impl ::fidl_next::Encodable for DirectoryLinkRequest {
    type Encoded = WireDirectoryLinkRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryLinkRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                src,
                dst_parent_token,
                dst,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.src, encoder, src)?;

        ::fidl_next::Encode::encode(&mut self.dst_parent_token, encoder, dst_parent_token)?;

        ::fidl_next::Encode::encode(&mut self.dst, encoder, dst)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryLinkRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryLinkRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryLinkRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryLinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryLinkRequest> for DirectoryLinkRequest {
    #[inline]
    fn take_from(from: &WireDirectoryLinkRequest) -> Self {
        Self {
            src: ::fidl_next::TakeFrom::take_from(&from.src),

            dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

            dst: ::fidl_next::TakeFrom::take_from(&from.dst),
        }
    }
}

/// The wire type corresponding to [`DirectoryLinkRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryLinkRequest {
    pub src: ::fidl_next::WireString,

    pub dst_parent_token: ::fidl_next::fuchsia::WireHandle,

    pub dst: ::fidl_next::WireString,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryLinkRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryLinkRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut src,
                mut dst_parent_token,
                mut dst,

            } = slot;
        }

        ::fidl_next::Decode::decode(src.as_mut(), decoder)?;

        let src = unsafe { src.deref_unchecked() };

        if src.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: src.len() as u64,
                limit: 255,
            });
        }

        ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(dst.as_mut(), decoder)?;

        let dst = unsafe { dst.deref_unchecked() };

        if dst.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: dst.len() as u64,
                limit: 255,
            });
        }

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryLinkResponse {
    pub s: i32,
}

impl ::fidl_next::Encodable for DirectoryLinkResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireDirectoryLinkResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryLinkResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryLinkResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryLinkResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryLinkResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryLinkResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryLinkResponse> for DirectoryLinkResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryLinkResponse) -> Self {
        Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
    }
}

/// The wire type corresponding to [`DirectoryLinkResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDirectoryLinkResponse {
    pub s: ::fidl_next::WireI32,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryLinkResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryLinkResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        Ok(())
    }
}

::fidl_next::bitflags! {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
    )]
    pub struct UnlinkFlags: u64 {
        #[doc = " If set, the unlink will fail (with ZX_ERR_NOT_DIR) if the\n object is not a directory.\n"]const MUST_BE_DIRECTORY = 1;
        const _ = !0;
    }
}

impl ::fidl_next::Encodable for UnlinkFlags {
    type Encoded = WireUnlinkFlags;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UnlinkFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUnlinkFlags { value } = out);
        let _ = value.write(::fidl_next::WireU64::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireUnlinkFlags> for UnlinkFlags {
    fn from(wire: WireUnlinkFlags) -> Self {
        Self::from_bits_retain(u64::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireUnlinkFlags> for UnlinkFlags {
    #[inline]
    fn take_from(from: &WireUnlinkFlags) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`UnlinkFlags`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireUnlinkFlags {
    value: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireUnlinkFlags {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnlinkFlags
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<UnlinkFlags> for WireUnlinkFlags {
    fn from(natural: UnlinkFlags) -> Self {
        Self { value: ::fidl_next::WireU64::from(natural.bits()) }
    }
}

#[derive(Clone, Debug)]
pub struct UnlinkOptions {
    pub flags: Option<crate::UnlinkFlags>,
}

impl UnlinkOptions {
    fn __max_ordinal(&self) -> usize {
        if self.flags.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UnlinkOptions {
    type Encoded = WireUnlinkOptions;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UnlinkOptions
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUnlinkOptions { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(flags) = &mut self.flags {
                        ::fidl_next::WireEnvelope::encode_value(
                            flags,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireUnlinkOptions> for UnlinkOptions {
    #[inline]
    fn take_from(from: &WireUnlinkOptions) -> Self {
        Self { flags: from.flags().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`UnlinkOptions`].
#[repr(C)]
pub struct WireUnlinkOptions {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireUnlinkOptions {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnlinkOptions
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireUnlinkFlags>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireUnlinkOptions {
    pub fn flags(&self) -> Option<&crate::WireUnlinkFlags> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUnlinkOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UnlinkOptions").field("flags", &self.flags()).finish()
    }
}

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

    pub options: crate::UnlinkOptions,
}

impl ::fidl_next::Encodable for DirectoryUnlinkRequest {
    type Encoded = WireDirectoryUnlinkRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryUnlinkRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                name,
                options,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        ::fidl_next::Encode::encode(&mut self.options, encoder, options)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryUnlinkRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryUnlinkRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryUnlinkRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryUnlinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryUnlinkRequest> for DirectoryUnlinkRequest {
    #[inline]
    fn take_from(from: &WireDirectoryUnlinkRequest) -> Self {
        Self {
            name: ::fidl_next::TakeFrom::take_from(&from.name),

            options: ::fidl_next::TakeFrom::take_from(&from.options),
        }
    }
}

/// The wire type corresponding to [`DirectoryUnlinkRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryUnlinkRequest {
    pub name: ::fidl_next::WireString,

    pub options: crate::WireUnlinkOptions,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryUnlinkRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryUnlinkRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut name,
                mut options,

            } = slot;
        }

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        let name = unsafe { name.deref_unchecked() };

        if name.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: name.len() as u64,
                limit: 255,
            });
        }

        ::fidl_next::Decode::decode(options.as_mut(), decoder)?;

        Ok(())
    }
}

pub type DirectoryUnlinkResponse = ();

/// The wire type corresponding to [`DirectoryUnlinkResponse`].
pub type WireDirectoryUnlinkResponse = ();

#[doc = " The type to identify a connection to a node.\n It represents a capability: a reference to a node with associated rights.\n"]
pub type Token = ::fidl_next::fuchsia::zx::Handle;

/// The wire type corresponding to [`Token`].
pub type WireToken = ::fidl_next::fuchsia::WireHandle;

#[derive(Debug)]
pub struct DirectoryRenameRequest {
    pub src: String,

    pub dst_parent_token: ::fidl_next::fuchsia::zx::Handle,

    pub dst: String,
}

impl ::fidl_next::Encodable for DirectoryRenameRequest {
    type Encoded = WireDirectoryRenameRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRenameRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                src,
                dst_parent_token,
                dst,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.src, encoder, src)?;

        ::fidl_next::Encode::encode(&mut self.dst_parent_token, encoder, dst_parent_token)?;

        ::fidl_next::Encode::encode(&mut self.dst, encoder, dst)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryRenameRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryRenameRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryRenameRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryRenameRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryRenameRequest> for DirectoryRenameRequest {
    #[inline]
    fn take_from(from: &WireDirectoryRenameRequest) -> Self {
        Self {
            src: ::fidl_next::TakeFrom::take_from(&from.src),

            dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

            dst: ::fidl_next::TakeFrom::take_from(&from.dst),
        }
    }
}

/// The wire type corresponding to [`DirectoryRenameRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryRenameRequest {
    pub src: ::fidl_next::WireString,

    pub dst_parent_token: ::fidl_next::fuchsia::WireHandle,

    pub dst: ::fidl_next::WireString,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryRenameRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryRenameRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut src,
                mut dst_parent_token,
                mut dst,

            } = slot;
        }

        ::fidl_next::Decode::decode(src.as_mut(), decoder)?;

        let src = unsafe { src.deref_unchecked() };

        if src.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: src.len() as u64,
                limit: 255,
            });
        }

        ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(dst.as_mut(), decoder)?;

        let dst = unsafe { dst.deref_unchecked() };

        if dst.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: dst.len() as u64,
                limit: 255,
            });
        }

        Ok(())
    }
}

pub type DirectoryRenameResponse = ();

/// The wire type corresponding to [`DirectoryRenameResponse`].
pub type WireDirectoryRenameResponse = ();

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

    }
}

impl ::fidl_next::Encodable for WatchMask {
    type Encoded = WireWatchMask;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for WatchMask
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireWatchMask { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireWatchMask> for WatchMask {
    fn from(wire: WireWatchMask) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireWatchMask> for WatchMask {
    #[inline]
    fn take_from(from: &WireWatchMask) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`WatchMask`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireWatchMask {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireWatchMask {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWatchMask
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !WatchMask::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: WatchMask::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<WatchMask> for WireWatchMask {
    fn from(natural: WatchMask) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirectoryWatchRequest {
    pub mask: crate::WatchMask,

    pub options: u32,

    pub watcher: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::DirectoryWatcher>,
}

impl ::fidl_next::Encodable for DirectoryWatchRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::WatchMask as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <::fidl_next::ServerEnd<
                    ::fidl_next::fuchsia::zx::Channel,
                    crate::DirectoryWatcher,
                > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    type Encoded = WireDirectoryWatchRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryWatchRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                mask,
                options,
                watcher,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.mask, encoder, mask)?;

        ::fidl_next::Encode::encode(&mut self.options, encoder, options)?;

        ::fidl_next::Encode::encode(&mut self.watcher, encoder, watcher)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryWatchRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryWatchRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryWatchRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryWatchRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryWatchRequest> for DirectoryWatchRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::WatchMask as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <::fidl_next::ServerEnd<
                    ::fidl_next::fuchsia::zx::Channel,
                    crate::DirectoryWatcher,
                > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryWatchRequest) -> Self {
        Self {
            mask: ::fidl_next::TakeFrom::take_from(&from.mask),

            options: ::fidl_next::TakeFrom::take_from(&from.options),

            watcher: ::fidl_next::TakeFrom::take_from(&from.watcher),
        }
    }
}

/// The wire type corresponding to [`DirectoryWatchRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryWatchRequest {
    pub mask: crate::WireWatchMask,

    pub options: ::fidl_next::WireU32,

    pub watcher: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::DirectoryWatcher>,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryWatchRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryWatchRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut mask,
                mut options,
                mut watcher,

            } = slot;
        }

        ::fidl_next::Decode::decode(mask.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(options.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(watcher.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryWatchResponse {
    pub s: i32,
}

impl ::fidl_next::Encodable for DirectoryWatchResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireDirectoryWatchResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryWatchResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryWatchResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryWatchResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryWatchResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryWatchResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryWatchResponse> for DirectoryWatchResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireDirectoryWatchResponse) -> Self {
        Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
    }
}

/// The wire type corresponding to [`DirectoryWatchResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDirectoryWatchResponse {
    pub s: ::fidl_next::WireI32,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryWatchResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryWatchResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Debug)]
pub struct NodeOnOpenRequest {
    pub s: i32,

    pub info: Option<Box<crate::NodeInfoDeprecated>>,
}

impl ::fidl_next::Encodable for NodeOnOpenRequest {
    type Encoded = WireNodeOnOpenRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeOnOpenRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                info,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.info, encoder, info)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeOnOpenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeOnOpenRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeOnOpenRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeOnOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeOnOpenRequest> for NodeOnOpenRequest {
    #[inline]
    fn take_from(from: &WireNodeOnOpenRequest) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            info: ::fidl_next::TakeFrom::take_from(&from.info),
        }
    }
}

/// The wire type corresponding to [`NodeOnOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeOnOpenRequest {
    pub s: ::fidl_next::WireI32,

    pub info: crate::WireOptionalNodeInfoDeprecated,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeOnOpenRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeOnOpenRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut info,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(info.as_mut(), decoder)?;

        Ok(())
    }
}

pub type SymlinkTarget = Vec<u8>;

/// The wire type corresponding to [`SymlinkTarget`].
pub type WireSymlinkTarget = ::fidl_next::WireVector<u8>;

#[derive(Debug)]
#[repr(C)]
pub struct NodeListExtendedAttributesRequest {
    pub iterator:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::ExtendedAttributeIterator>,
}

impl ::fidl_next::Encodable for NodeListExtendedAttributesRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                ::fidl_next::fuchsia::zx::Channel,
                crate::ExtendedAttributeIterator,
            > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    type Encoded = WireNodeListExtendedAttributesRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeListExtendedAttributesRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                iterator,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.iterator, encoder, iterator)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeListExtendedAttributesRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeListExtendedAttributesRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeListExtendedAttributesRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeListExtendedAttributesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeListExtendedAttributesRequest>
    for NodeListExtendedAttributesRequest
{
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                ::fidl_next::fuchsia::zx::Channel,
                crate::ExtendedAttributeIterator,
            > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeListExtendedAttributesRequest) -> Self {
        Self { iterator: ::fidl_next::TakeFrom::take_from(&from.iterator) }
    }
}

/// The wire type corresponding to [`NodeListExtendedAttributesRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeListExtendedAttributesRequest {
    pub iterator:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::ExtendedAttributeIterator>,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeListExtendedAttributesRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeListExtendedAttributesRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut iterator,

            } = slot;
        }

        ::fidl_next::Decode::decode(iterator.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " The maximum size for an extended attribute name.\n"]
pub const MAX_ATTRIBUTE_NAME: u64 = 255;

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

/// The wire type corresponding to [`ExtendedAttributeName`].
pub type WireExtendedAttributeName = ::fidl_next::WireVector<u8>;

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

impl ::fidl_next::Encodable for NodeGetExtendedAttributeRequest {
    type Encoded = WireNodeGetExtendedAttributeRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeGetExtendedAttributeRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                name,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeGetExtendedAttributeRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeGetExtendedAttributeRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeGetExtendedAttributeRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeGetExtendedAttributeRequest>
    for NodeGetExtendedAttributeRequest
{
    #[inline]
    fn take_from(from: &WireNodeGetExtendedAttributeRequest) -> Self {
        Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
    }
}

/// The wire type corresponding to [`NodeGetExtendedAttributeRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeGetExtendedAttributeRequest {
    pub name: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeGetExtendedAttributeRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeGetExtendedAttributeRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut name,

            } = slot;
        }

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        let name = unsafe { name.deref_unchecked() };

        if name.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: name.len() as u64,
                limit: 255,
            });
        }

        Ok(())
    }
}

#[doc = " The maximum size for an extended attribute value to be included inline.\n Values larger than this size are passed in a vmo.\n"]
pub const MAX_INLINE_ATTRIBUTE_VALUE: u64 = 32768;

#[doc = " The value type for an extended attribute. If the value is less than 32768\n bytes, then it is included inline. Values larger than this size are written\n into a vmo buffer.\n"]
#[derive(Debug)]
pub enum ExtendedAttributeValue {
    Bytes(Vec<u8>),

    Buffer(::fidl_next::fuchsia::zx::Handle),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ExtendedAttributeValue {
    type Encoded = WireExtendedAttributeValue;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExtendedAttributeValue
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExtendedAttributeValue { raw } = out);

        match self {
            Self::Bytes(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<u8>>(value, 1, encoder, raw)?
            }

            Self::Buffer(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::fuchsia::zx::Handle,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ExtendedAttributeValue> {
    type EncodedOption = WireOptionalExtendedAttributeValue;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ExtendedAttributeValue>
where
    ___E: ?Sized,
    ExtendedAttributeValue: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalExtendedAttributeValue { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireExtendedAttributeValue> for ExtendedAttributeValue {
    #[inline]
    fn take_from(from: &WireExtendedAttributeValue) -> Self {
        match from.raw.ordinal() {
            1 => Self::Bytes(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>()
            })),

            2 => Self::Buffer(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalExtendedAttributeValue>
    for Option<Box<ExtendedAttributeValue>>
{
    #[inline]
    fn take_from(from: &WireOptionalExtendedAttributeValue) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`ExtendedAttributeValue`].
#[repr(transparent)]
pub struct WireExtendedAttributeValue {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireExtendedAttributeValue {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod extended_attribute_value {
    pub enum Ref<'union> {
        Bytes(&'union ::fidl_next::WireVector<u8>),

        Buffer(&'union ::fidl_next::fuchsia::WireHandle),

        UnknownOrdinal_(u64),
    }
}

impl WireExtendedAttributeValue {
    pub fn as_ref(&self) -> crate::extended_attribute_value::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::extended_attribute_value::Ref::Bytes(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>()
            }),

            2 => crate::extended_attribute_value::Ref::Buffer(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
            }),

            unknown => crate::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireExtendedAttributeValue
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                raw, decoder,
            )?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireExtendedAttributeValue {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>().fmt(f) },
            2 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalExtendedAttributeValue {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalExtendedAttributeValue {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalExtendedAttributeValue {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> Option<&WireExtendedAttributeValue> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalExtendedAttributeValue
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                raw, decoder,
            )?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalExtendedAttributeValue {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum SetExtendedAttributeMode {
    Set = 1,
    Create = 2,
    Replace = 3,
}

impl ::fidl_next::Encodable for SetExtendedAttributeMode {
    type Encoded = WireSetExtendedAttributeMode;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SetExtendedAttributeMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSetExtendedAttributeMode { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Set => 1,

            Self::Create => 2,

            Self::Replace => 3,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireSetExtendedAttributeMode> for SetExtendedAttributeMode {
    fn from(wire: WireSetExtendedAttributeMode) -> Self {
        match u32::from(wire.value) {
            1 => Self::Set,

            2 => Self::Create,

            3 => Self::Replace,

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireSetExtendedAttributeMode> for SetExtendedAttributeMode {
    #[inline]
    fn take_from(from: &WireSetExtendedAttributeMode) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`SetExtendedAttributeMode`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireSetExtendedAttributeMode {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireSetExtendedAttributeMode {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireSetExtendedAttributeMode {
    pub const SET: WireSetExtendedAttributeMode =
        WireSetExtendedAttributeMode { value: ::fidl_next::WireU32(1) };

    pub const CREATE: WireSetExtendedAttributeMode =
        WireSetExtendedAttributeMode { value: ::fidl_next::WireU32(2) };

    pub const REPLACE: WireSetExtendedAttributeMode =
        WireSetExtendedAttributeMode { value: ::fidl_next::WireU32(3) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSetExtendedAttributeMode
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);

        match u32::from(*value) {
            1 | 2 | 3 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

impl ::core::convert::From<SetExtendedAttributeMode> for WireSetExtendedAttributeMode {
    fn from(natural: SetExtendedAttributeMode) -> Self {
        match natural {
            SetExtendedAttributeMode::Set => WireSetExtendedAttributeMode::SET,

            SetExtendedAttributeMode::Create => WireSetExtendedAttributeMode::CREATE,

            SetExtendedAttributeMode::Replace => WireSetExtendedAttributeMode::REPLACE,
        }
    }
}

#[derive(Debug)]
pub struct NodeSetExtendedAttributeRequest {
    pub name: Vec<u8>,

    pub value: crate::ExtendedAttributeValue,

    pub mode: crate::SetExtendedAttributeMode,
}

impl ::fidl_next::Encodable for NodeSetExtendedAttributeRequest {
    type Encoded = WireNodeSetExtendedAttributeRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeSetExtendedAttributeRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                name,
                value,
                mode,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        ::fidl_next::Encode::encode(&mut self.value, encoder, value)?;

        ::fidl_next::Encode::encode(&mut self.mode, encoder, mode)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeSetExtendedAttributeRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeSetExtendedAttributeRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeSetExtendedAttributeRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeSetExtendedAttributeRequest>
    for NodeSetExtendedAttributeRequest
{
    #[inline]
    fn take_from(from: &WireNodeSetExtendedAttributeRequest) -> Self {
        Self {
            name: ::fidl_next::TakeFrom::take_from(&from.name),

            value: ::fidl_next::TakeFrom::take_from(&from.value),

            mode: ::fidl_next::TakeFrom::take_from(&from.mode),
        }
    }
}

/// The wire type corresponding to [`NodeSetExtendedAttributeRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeSetExtendedAttributeRequest {
    pub name: ::fidl_next::WireVector<u8>,

    pub value: crate::WireExtendedAttributeValue,

    pub mode: crate::WireSetExtendedAttributeMode,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeSetExtendedAttributeRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeSetExtendedAttributeRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut name,
                mut value,
                mut mode,

            } = slot;
        }

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        let name = unsafe { name.deref_unchecked() };

        if name.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: name.len() as u64,
                limit: 255,
            });
        }

        ::fidl_next::Decode::decode(value.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(mode.as_mut(), decoder)?;

        Ok(())
    }
}

pub type NodeSetExtendedAttributeResponse = ();

/// The wire type corresponding to [`NodeSetExtendedAttributeResponse`].
pub type WireNodeSetExtendedAttributeResponse = ();

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

impl ::fidl_next::Encodable for NodeRemoveExtendedAttributeRequest {
    type Encoded = WireNodeRemoveExtendedAttributeRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeRemoveExtendedAttributeRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                name,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeRemoveExtendedAttributeRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeRemoveExtendedAttributeRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeRemoveExtendedAttributeRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeRemoveExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeRemoveExtendedAttributeRequest>
    for NodeRemoveExtendedAttributeRequest
{
    #[inline]
    fn take_from(from: &WireNodeRemoveExtendedAttributeRequest) -> Self {
        Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
    }
}

/// The wire type corresponding to [`NodeRemoveExtendedAttributeRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeRemoveExtendedAttributeRequest {
    pub name: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeRemoveExtendedAttributeRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeRemoveExtendedAttributeRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut name,

            } = slot;
        }

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        let name = unsafe { name.deref_unchecked() };

        if name.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: name.len() as u64,
                limit: 255,
            });
        }

        Ok(())
    }
}

pub type NodeRemoveExtendedAttributeResponse = ();

/// The wire type corresponding to [`NodeRemoveExtendedAttributeResponse`].
pub type WireNodeRemoveExtendedAttributeResponse = ();

pub type DirectoryCreateSymlinkResponse = ();

/// The wire type corresponding to [`DirectoryCreateSymlinkResponse`].
pub type WireDirectoryCreateSymlinkResponse = ();

pub type NodeSetFlagsResponse = ();

/// The wire type corresponding to [`NodeSetFlagsResponse`].
pub type WireNodeSetFlagsResponse = ();

#[derive(Debug)]
#[repr(C)]
pub struct NodeDeprecatedCloneRequest {
    pub flags: crate::OpenFlags,

    pub object: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Node>,
}

impl ::fidl_next::Encodable for NodeDeprecatedCloneRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    crate::OpenFlags as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Node,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireNodeDeprecatedCloneRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedCloneRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,
                object,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        ::fidl_next::Encode::encode(&mut self.object, encoder, object)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeDeprecatedCloneRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeDeprecatedCloneRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeDeprecatedCloneRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedCloneRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeDeprecatedCloneRequest> for NodeDeprecatedCloneRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    crate::OpenFlags as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Node,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireNodeDeprecatedCloneRequest) -> Self {
        Self {
            flags: ::fidl_next::TakeFrom::take_from(&from.flags),

            object: ::fidl_next::TakeFrom::take_from(&from.object),
        }
    }
}

/// The wire type corresponding to [`NodeDeprecatedCloneRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeDeprecatedCloneRequest {
    pub flags: crate::WireOpenFlags,

    pub object: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Node>,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeDeprecatedCloneRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeDeprecatedCloneRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,
                mut object,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(object.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeDeprecatedGetFlagsResponse {
    pub s: i32,

    pub flags: crate::OpenFlags,
}

impl ::fidl_next::Encodable for NodeDeprecatedGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <crate::OpenFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeDeprecatedGetFlagsResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedGetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,
                flags,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeDeprecatedGetFlagsResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeDeprecatedGetFlagsResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeDeprecatedGetFlagsResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedGetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeDeprecatedGetFlagsResponse> for NodeDeprecatedGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <crate::OpenFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeDeprecatedGetFlagsResponse) -> Self {
        Self {
            s: ::fidl_next::TakeFrom::take_from(&from.s),

            flags: ::fidl_next::TakeFrom::take_from(&from.flags),
        }
    }
}

/// The wire type corresponding to [`NodeDeprecatedGetFlagsResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeDeprecatedGetFlagsResponse {
    pub s: ::fidl_next::WireI32,

    pub flags: crate::WireOpenFlags,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeDeprecatedGetFlagsResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeDeprecatedGetFlagsResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,
                mut flags,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeDeprecatedSetFlagsRequest {
    pub flags: crate::OpenFlags,
}

impl ::fidl_next::Encodable for NodeDeprecatedSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::OpenFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeDeprecatedSetFlagsRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedSetFlagsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeDeprecatedSetFlagsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeDeprecatedSetFlagsRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeDeprecatedSetFlagsRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeDeprecatedSetFlagsRequest> for NodeDeprecatedSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::OpenFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeDeprecatedSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
    }
}

/// The wire type corresponding to [`NodeDeprecatedSetFlagsRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeDeprecatedSetFlagsRequest {
    pub flags: crate::WireOpenFlags,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeDeprecatedSetFlagsRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeDeprecatedSetFlagsRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeDeprecatedSetFlagsResponse {
    pub s: i32,
}

impl ::fidl_next::Encodable for NodeDeprecatedSetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeDeprecatedSetFlagsResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedSetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                s,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeDeprecatedSetFlagsResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeDeprecatedSetFlagsResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeDeprecatedSetFlagsResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeDeprecatedSetFlagsResponse> for NodeDeprecatedSetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeDeprecatedSetFlagsResponse) -> Self {
        Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
    }
}

/// The wire type corresponding to [`NodeDeprecatedSetFlagsResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeDeprecatedSetFlagsResponse {
    pub s: ::fidl_next::WireI32,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeDeprecatedSetFlagsResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeDeprecatedSetFlagsResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut s,

            } = slot;
        }

        ::fidl_next::Decode::decode(s.as_mut(), decoder)?;

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for Flags {
    type Encoded = WireFlags;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Flags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireFlags { value } = out);
        let _ = value.write(::fidl_next::WireU64::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireFlags> for Flags {
    fn from(wire: WireFlags) -> Self {
        Self::from_bits_retain(u64::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireFlags> for Flags {
    #[inline]
    fn take_from(from: &WireFlags) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`Flags`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireFlags {
    value: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFlags {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFlags
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<Flags> for WireFlags {
    fn from(natural: Flags) -> Self {
        Self { value: ::fidl_next::WireU64::from(natural.bits()) }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeGetFlagsResponse {
    pub flags: crate::Flags,
}

impl ::fidl_next::Encodable for NodeGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeGetFlagsResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeGetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeGetFlagsResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeGetFlagsResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeGetFlagsResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeGetFlagsResponse> for NodeGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeGetFlagsResponse) -> Self {
        Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
    }
}

/// The wire type corresponding to [`NodeGetFlagsResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeGetFlagsResponse {
    pub flags: crate::WireFlags,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeGetFlagsResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeGetFlagsResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeSetFlagsRequest {
    pub flags: crate::Flags,
}

impl ::fidl_next::Encodable for NodeSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireNodeSetFlagsRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeSetFlagsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeSetFlagsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeSetFlagsRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeSetFlagsRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetFlagsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeSetFlagsRequest> for NodeSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
    }
}

/// The wire type corresponding to [`NodeSetFlagsRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeSetFlagsRequest {
    pub flags: crate::WireFlags,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeSetFlagsRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeSetFlagsRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " The maximum size for passing the SELinux context as an attribute.\n"]
pub const MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN: u64 = 256;

#[doc = " Used in places where empty structs are needed, such as empty union members, to avoid creating\n new struct types.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct EmptyStruct {}

impl ::fidl_next::Encodable for EmptyStruct {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    type Encoded = WireEmptyStruct;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for EmptyStruct
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<EmptyStruct> {
    type EncodedOption = ::fidl_next::WireBox<WireEmptyStruct>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<EmptyStruct>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    EmptyStruct: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireEmptyStruct> for EmptyStruct {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn take_from(from: &WireEmptyStruct) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`EmptyStruct`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireEmptyStruct {}

unsafe impl ::fidl_next::ZeroPadding for WireEmptyStruct {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireEmptyStruct
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

            } = slot;
        }

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub enum SelinuxContext {
    Data(Vec<u8>),

    UseExtendedAttributes(crate::EmptyStruct),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for SelinuxContext {
    type Encoded = WireSelinuxContext;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SelinuxContext
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSelinuxContext { raw } = out);

        match self {
            Self::Data(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<u8>>(value, 1, encoder, raw)?
            }

            Self::UseExtendedAttributes(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::EmptyStruct,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<SelinuxContext> {
    type EncodedOption = WireOptionalSelinuxContext;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<SelinuxContext>
where
    ___E: ?Sized,
    SelinuxContext: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalSelinuxContext { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireSelinuxContext> for SelinuxContext {
    #[inline]
    fn take_from(from: &WireSelinuxContext) -> Self {
        match from.raw.ordinal() {
            1 => Self::Data(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>()
            })),

            2 => Self::UseExtendedAttributes(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireEmptyStruct>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalSelinuxContext> for Option<Box<SelinuxContext>> {
    #[inline]
    fn take_from(from: &WireOptionalSelinuxContext) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`SelinuxContext`].
#[repr(transparent)]
pub struct WireSelinuxContext {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireSelinuxContext {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod selinux_context {
    pub enum Ref<'union> {
        Data(&'union ::fidl_next::WireVector<u8>),

        UseExtendedAttributes(&'union crate::WireEmptyStruct),

        UnknownOrdinal_(u64),
    }
}

impl WireSelinuxContext {
    pub fn as_ref(&self) -> crate::selinux_context::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::selinux_context::Ref::Data(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>()
            }),

            2 => crate::selinux_context::Ref::UseExtendedAttributes(unsafe {
                self.raw.get().deref_unchecked::<crate::WireEmptyStruct>()
            }),

            unknown => crate::selinux_context::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSelinuxContext
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                raw, decoder,
            )?,

            2 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireEmptyStruct>(raw, decoder)?
            }

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireSelinuxContext {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireVector<u8>>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireEmptyStruct>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalSelinuxContext {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalSelinuxContext {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalSelinuxContext {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> Option<&WireSelinuxContext> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalSelinuxContext
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                raw, decoder,
            )?,

            2 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireEmptyStruct>(raw, decoder)?
            }

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalSelinuxContext {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[derive(Clone, Debug)]
pub struct MutableNodeAttributes {
    pub creation_time: Option<u64>,

    pub modification_time: Option<u64>,

    pub mode: Option<u32>,

    pub uid: Option<u32>,

    pub gid: Option<u32>,

    pub rdev: Option<u64>,

    pub access_time: Option<u64>,

    pub casefold: Option<bool>,

    pub selinux_context: Option<crate::SelinuxContext>,

    pub wrapping_key_id: Option<[u8; 16]>,
}

impl MutableNodeAttributes {
    fn __max_ordinal(&self) -> usize {
        if self.creation_time.is_some() {
            return 1;
        }

        if self.modification_time.is_some() {
            return 2;
        }

        if self.mode.is_some() {
            return 3;
        }

        if self.uid.is_some() {
            return 4;
        }

        if self.gid.is_some() {
            return 5;
        }

        if self.rdev.is_some() {
            return 6;
        }

        if self.access_time.is_some() {
            return 7;
        }

        if self.casefold.is_some() {
            return 8;
        }

        if self.selinux_context.is_some() {
            return 9;
        }

        if self.wrapping_key_id.is_some() {
            return 10;
        }

        0
    }
}

impl ::fidl_next::Encodable for MutableNodeAttributes {
    type Encoded = WireMutableNodeAttributes;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for MutableNodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireMutableNodeAttributes { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                10 => {
                    if let Some(wrapping_key_id) = &mut self.wrapping_key_id {
                        ::fidl_next::WireEnvelope::encode_value(
                            wrapping_key_id,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                9 => {
                    if let Some(selinux_context) = &mut self.selinux_context {
                        ::fidl_next::WireEnvelope::encode_value(
                            selinux_context,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(casefold) = &mut self.casefold {
                        ::fidl_next::WireEnvelope::encode_value(
                            casefold,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(access_time) = &mut self.access_time {
                        ::fidl_next::WireEnvelope::encode_value(
                            access_time,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(rdev) = &mut self.rdev {
                        ::fidl_next::WireEnvelope::encode_value(
                            rdev,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(gid) = &mut self.gid {
                        ::fidl_next::WireEnvelope::encode_value(
                            gid,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(uid) = &mut self.uid {
                        ::fidl_next::WireEnvelope::encode_value(
                            uid,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(mode) = &mut self.mode {
                        ::fidl_next::WireEnvelope::encode_value(
                            mode,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(modification_time) = &mut self.modification_time {
                        ::fidl_next::WireEnvelope::encode_value(
                            modification_time,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(creation_time) = &mut self.creation_time {
                        ::fidl_next::WireEnvelope::encode_value(
                            creation_time,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireMutableNodeAttributes> for MutableNodeAttributes {
    #[inline]
    fn take_from(from: &WireMutableNodeAttributes) -> Self {
        Self {
            creation_time: from.creation_time().map(::fidl_next::TakeFrom::take_from),

            modification_time: from.modification_time().map(::fidl_next::TakeFrom::take_from),

            mode: from.mode().map(::fidl_next::TakeFrom::take_from),

            uid: from.uid().map(::fidl_next::TakeFrom::take_from),

            gid: from.gid().map(::fidl_next::TakeFrom::take_from),

            rdev: from.rdev().map(::fidl_next::TakeFrom::take_from),

            access_time: from.access_time().map(::fidl_next::TakeFrom::take_from),

            casefold: from.casefold().map(::fidl_next::TakeFrom::take_from),

            selinux_context: from.selinux_context().map(::fidl_next::TakeFrom::take_from),

            wrapping_key_id: from.wrapping_key_id().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`MutableNodeAttributes`].
#[repr(C)]
pub struct WireMutableNodeAttributes {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireMutableNodeAttributes {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireMutableNodeAttributes
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU32>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU32>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU32>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireSelinuxContext>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, [u8; 16]>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireMutableNodeAttributes {
    pub fn creation_time(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn modification_time(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn mode(&self) -> Option<&::fidl_next::WireU32> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn uid(&self) -> Option<&::fidl_next::WireU32> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn gid(&self) -> Option<&::fidl_next::WireU32> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn rdev(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn access_time(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn casefold(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn selinux_context(&self) -> Option<&crate::WireSelinuxContext> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn wrapping_key_id(&self) -> Option<&[u8; 16]> {
        unsafe { Some(self.table.get(10)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireMutableNodeAttributes {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("MutableNodeAttributes")
            .field("creation_time", &self.creation_time())
            .field("modification_time", &self.modification_time())
            .field("mode", &self.mode())
            .field("uid", &self.uid())
            .field("gid", &self.gid())
            .field("rdev", &self.rdev())
            .field("access_time", &self.access_time())
            .field("casefold", &self.casefold())
            .field("selinux_context", &self.selinux_context())
            .field("wrapping_key_id", &self.wrapping_key_id())
            .finish()
    }
}

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

impl ::fidl_next::Encodable for NodeProtocolKinds {
    type Encoded = WireNodeProtocolKinds;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeProtocolKinds
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeProtocolKinds { value } = out);
        let _ = value.write(::fidl_next::WireU64::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireNodeProtocolKinds> for NodeProtocolKinds {
    fn from(wire: WireNodeProtocolKinds) -> Self {
        Self::from_bits_retain(u64::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireNodeProtocolKinds> for NodeProtocolKinds {
    #[inline]
    fn take_from(from: &WireNodeProtocolKinds) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`NodeProtocolKinds`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireNodeProtocolKinds {
    value: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeProtocolKinds {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeProtocolKinds
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<NodeProtocolKinds> for WireNodeProtocolKinds {
    fn from(natural: NodeProtocolKinds) -> Self {
        Self { value: ::fidl_next::WireU64::from(natural.bits()) }
    }
}

#[doc = " Denotes which hash algorithm is used to build the merkle tree for\n fsverity-enabled files.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum HashAlgorithm {
    Sha256 = 1,
    Sha512 = 2,
    UnknownOrdinal_(u8),
}

impl ::fidl_next::Encodable for HashAlgorithm {
    type Encoded = WireHashAlgorithm;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for HashAlgorithm
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireHashAlgorithm { value } = out);
        let _ = value.write(u8::from(match *self {
            Self::Sha256 => 1,

            Self::Sha512 => 2,

            Self::UnknownOrdinal_(value) => value,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireHashAlgorithm> for HashAlgorithm {
    fn from(wire: WireHashAlgorithm) -> Self {
        match u8::from(wire.value) {
            1 => Self::Sha256,

            2 => Self::Sha512,

            value => Self::UnknownOrdinal_(value),
        }
    }
}

impl ::fidl_next::TakeFrom<WireHashAlgorithm> for HashAlgorithm {
    #[inline]
    fn take_from(from: &WireHashAlgorithm) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`HashAlgorithm`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireHashAlgorithm {
    value: u8,
}

unsafe impl ::fidl_next::ZeroPadding for WireHashAlgorithm {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireHashAlgorithm {
    pub const SHA256: WireHashAlgorithm = WireHashAlgorithm { value: 1 };

    pub const SHA512: WireHashAlgorithm = WireHashAlgorithm { value: 2 };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireHashAlgorithm
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<HashAlgorithm> for WireHashAlgorithm {
    fn from(natural: HashAlgorithm) -> Self {
        match natural {
            HashAlgorithm::Sha256 => WireHashAlgorithm::SHA256,

            HashAlgorithm::Sha512 => WireHashAlgorithm::SHA512,

            HashAlgorithm::UnknownOrdinal_(value) => WireHashAlgorithm { value: u8::from(value) },
        }
    }
}

#[doc = " Set of options used to enable verity on a file.\n"]
#[derive(Clone, Debug)]
pub struct VerificationOptions {
    pub hash_algorithm: Option<crate::HashAlgorithm>,

    pub salt: Option<Vec<u8>>,
}

impl VerificationOptions {
    fn __max_ordinal(&self) -> usize {
        if self.hash_algorithm.is_some() {
            return 1;
        }

        if self.salt.is_some() {
            return 2;
        }

        0
    }
}

impl ::fidl_next::Encodable for VerificationOptions {
    type Encoded = WireVerificationOptions;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for VerificationOptions
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireVerificationOptions { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(salt) = &mut self.salt {
                        ::fidl_next::WireEnvelope::encode_value(
                            salt,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(hash_algorithm) = &mut self.hash_algorithm {
                        ::fidl_next::WireEnvelope::encode_value(
                            hash_algorithm,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireVerificationOptions> for VerificationOptions {
    #[inline]
    fn take_from(from: &WireVerificationOptions) -> Self {
        Self {
            hash_algorithm: from.hash_algorithm().map(::fidl_next::TakeFrom::take_from),

            salt: from.salt().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`VerificationOptions`].
#[repr(C)]
pub struct WireVerificationOptions {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireVerificationOptions {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireVerificationOptions
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireHashAlgorithm>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let salt = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireVector<u8>>()
                    };

                    if salt.len() > 32 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: salt.len() as u64,
                            limit: 32,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireVerificationOptions {
    pub fn hash_algorithm(&self) -> Option<&crate::WireHashAlgorithm> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn salt(&self) -> Option<&::fidl_next::WireVector<u8>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireVerificationOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("VerificationOptions")
            .field("hash_algorithm", &self.hash_algorithm())
            .field("salt", &self.salt())
            .finish()
    }
}

#[derive(Clone, Debug)]
pub struct ImmutableNodeAttributes {
    pub protocols: Option<crate::NodeProtocolKinds>,

    pub abilities: Option<crate::Operations>,

    pub content_size: Option<u64>,

    pub storage_size: Option<u64>,

    pub link_count: Option<u64>,

    pub id: Option<u64>,

    pub change_time: Option<u64>,

    pub options: Option<crate::VerificationOptions>,

    pub root_hash: Option<Vec<u8>>,

    pub verity_enabled: Option<bool>,
}

impl ImmutableNodeAttributes {
    fn __max_ordinal(&self) -> usize {
        if self.protocols.is_some() {
            return 1;
        }

        if self.abilities.is_some() {
            return 2;
        }

        if self.content_size.is_some() {
            return 3;
        }

        if self.storage_size.is_some() {
            return 4;
        }

        if self.link_count.is_some() {
            return 5;
        }

        if self.id.is_some() {
            return 6;
        }

        if self.change_time.is_some() {
            return 7;
        }

        if self.options.is_some() {
            return 8;
        }

        if self.root_hash.is_some() {
            return 9;
        }

        if self.verity_enabled.is_some() {
            return 10;
        }

        0
    }
}

impl ::fidl_next::Encodable for ImmutableNodeAttributes {
    type Encoded = WireImmutableNodeAttributes;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ImmutableNodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireImmutableNodeAttributes { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                10 => {
                    if let Some(verity_enabled) = &mut self.verity_enabled {
                        ::fidl_next::WireEnvelope::encode_value(
                            verity_enabled,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                9 => {
                    if let Some(root_hash) = &mut self.root_hash {
                        ::fidl_next::WireEnvelope::encode_value(
                            root_hash,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(options) = &mut self.options {
                        ::fidl_next::WireEnvelope::encode_value(
                            options,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(change_time) = &mut self.change_time {
                        ::fidl_next::WireEnvelope::encode_value(
                            change_time,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(id) = &mut self.id {
                        ::fidl_next::WireEnvelope::encode_value(
                            id,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(link_count) = &mut self.link_count {
                        ::fidl_next::WireEnvelope::encode_value(
                            link_count,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(storage_size) = &mut self.storage_size {
                        ::fidl_next::WireEnvelope::encode_value(
                            storage_size,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(content_size) = &mut self.content_size {
                        ::fidl_next::WireEnvelope::encode_value(
                            content_size,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(abilities) = &mut self.abilities {
                        ::fidl_next::WireEnvelope::encode_value(
                            abilities,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(protocols) = &mut self.protocols {
                        ::fidl_next::WireEnvelope::encode_value(
                            protocols,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireImmutableNodeAttributes> for ImmutableNodeAttributes {
    #[inline]
    fn take_from(from: &WireImmutableNodeAttributes) -> Self {
        Self {
            protocols: from.protocols().map(::fidl_next::TakeFrom::take_from),

            abilities: from.abilities().map(::fidl_next::TakeFrom::take_from),

            content_size: from.content_size().map(::fidl_next::TakeFrom::take_from),

            storage_size: from.storage_size().map(::fidl_next::TakeFrom::take_from),

            link_count: from.link_count().map(::fidl_next::TakeFrom::take_from),

            id: from.id().map(::fidl_next::TakeFrom::take_from),

            change_time: from.change_time().map(::fidl_next::TakeFrom::take_from),

            options: from.options().map(::fidl_next::TakeFrom::take_from),

            root_hash: from.root_hash().map(::fidl_next::TakeFrom::take_from),

            verity_enabled: from.verity_enabled().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`ImmutableNodeAttributes`].
#[repr(C)]
pub struct WireImmutableNodeAttributes {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireImmutableNodeAttributes {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireImmutableNodeAttributes
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeProtocolKinds>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireOperations>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireVerificationOptions>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let root_hash = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireVector<u8>>()
                    };

                    if root_hash.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: root_hash.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireImmutableNodeAttributes {
    pub fn protocols(&self) -> Option<&crate::WireNodeProtocolKinds> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn abilities(&self) -> Option<&crate::WireOperations> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn content_size(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn storage_size(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn link_count(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn id(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn change_time(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn options(&self) -> Option<&crate::WireVerificationOptions> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn root_hash(&self) -> Option<&::fidl_next::WireVector<u8>> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn verity_enabled(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(10)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireImmutableNodeAttributes {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ImmutableNodeAttributes")
            .field("protocols", &self.protocols())
            .field("abilities", &self.abilities())
            .field("content_size", &self.content_size())
            .field("storage_size", &self.storage_size())
            .field("link_count", &self.link_count())
            .field("id", &self.id())
            .field("change_time", &self.change_time())
            .field("options", &self.options())
            .field("root_hash", &self.root_hash())
            .field("verity_enabled", &self.verity_enabled())
            .finish()
    }
}

#[derive(Clone, Debug)]
pub struct NodeAttributes2 {
    pub mutable_attributes: crate::MutableNodeAttributes,

    pub immutable_attributes: crate::ImmutableNodeAttributes,
}

impl ::fidl_next::Encodable for NodeAttributes2 {
    type Encoded = WireNodeAttributes2;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAttributes2
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                mutable_attributes,
                immutable_attributes,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.mutable_attributes, encoder, mutable_attributes)?;

        ::fidl_next::Encode::encode(&mut self.immutable_attributes, encoder, immutable_attributes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeAttributes2> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeAttributes2>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeAttributes2>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes2: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeAttributes2> for NodeAttributes2 {
    #[inline]
    fn take_from(from: &WireNodeAttributes2) -> Self {
        Self {
            mutable_attributes: ::fidl_next::TakeFrom::take_from(&from.mutable_attributes),

            immutable_attributes: ::fidl_next::TakeFrom::take_from(&from.immutable_attributes),
        }
    }
}

/// The wire type corresponding to [`NodeAttributes2`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeAttributes2 {
    pub mutable_attributes: crate::WireMutableNodeAttributes,

    pub immutable_attributes: crate::WireImmutableNodeAttributes,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeAttributes2 {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAttributes2
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut mutable_attributes,
                mut immutable_attributes,

            } = slot;
        }

        ::fidl_next::Decode::decode(mutable_attributes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(immutable_attributes.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " Information that describes the target node.\n"]
#[derive(Clone, Debug)]
pub struct NodeInfo {
    pub attributes: Option<crate::NodeAttributes2>,
}

impl NodeInfo {
    fn __max_ordinal(&self) -> usize {
        if self.attributes.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for NodeInfo {
    type Encoded = WireNodeInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeInfo { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(attributes) = &mut self.attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeInfo> for NodeInfo {
    #[inline]
    fn take_from(from: &WireNodeInfo) -> Self {
        Self { attributes: from.attributes().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`NodeInfo`].
#[repr(C)]
pub struct WireNodeInfo {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeInfo
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeAttributes2>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireNodeInfo {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireNodeInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeInfo").field("attributes", &self.attributes()).finish()
    }
}

#[derive(Clone, Debug)]
pub struct DirectoryInfo {
    pub attributes: Option<crate::NodeAttributes2>,
}

impl DirectoryInfo {
    fn __max_ordinal(&self) -> usize {
        if self.attributes.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for DirectoryInfo {
    type Encoded = WireDirectoryInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDirectoryInfo { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(attributes) = &mut self.attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryInfo> for DirectoryInfo {
    #[inline]
    fn take_from(from: &WireDirectoryInfo) -> Self {
        Self { attributes: from.attributes().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`DirectoryInfo`].
#[repr(C)]
pub struct WireDirectoryInfo {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryInfo
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeAttributes2>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireDirectoryInfo {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireDirectoryInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DirectoryInfo").field("attributes", &self.attributes()).finish()
    }
}

#[doc = " Auxiliary data for the file representation of a node.\n"]
#[derive(Debug)]
pub struct FileInfo {
    pub is_append: Option<bool>,

    pub observer: Option<::fidl_next::fuchsia::zx::Handle>,

    pub stream: Option<::fidl_next::fuchsia::zx::Handle>,

    pub attributes: Option<crate::NodeAttributes2>,
}

impl FileInfo {
    fn __max_ordinal(&self) -> usize {
        if self.is_append.is_some() {
            return 1;
        }

        if self.observer.is_some() {
            return 2;
        }

        if self.stream.is_some() {
            return 3;
        }

        if self.attributes.is_some() {
            return 4;
        }

        0
    }
}

impl ::fidl_next::Encodable for FileInfo {
    type Encoded = WireFileInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireFileInfo { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                4 => {
                    if let Some(attributes) = &mut self.attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(stream) = &mut self.stream {
                        ::fidl_next::WireEnvelope::encode_value(
                            stream,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(observer) = &mut self.observer {
                        ::fidl_next::WireEnvelope::encode_value(
                            observer,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(is_append) = &mut self.is_append {
                        ::fidl_next::WireEnvelope::encode_value(
                            is_append,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileInfo> for FileInfo {
    #[inline]
    fn take_from(from: &WireFileInfo) -> Self {
        Self {
            is_append: from.is_append().map(::fidl_next::TakeFrom::take_from),

            observer: from.observer().map(::fidl_next::TakeFrom::take_from),

            stream: from.stream().map(::fidl_next::TakeFrom::take_from),

            attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`FileInfo`].
#[repr(C)]
pub struct WireFileInfo {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileInfo
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeAttributes2>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireFileInfo {
    pub fn is_append(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn observer(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn stream(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireFileInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("FileInfo")
            .field("is_append", &self.is_append())
            .field("observer", &self.observer())
            .field("stream", &self.stream())
            .field("attributes", &self.attributes())
            .finish()
    }
}

#[derive(Clone, Debug)]
pub struct SymlinkInfo {
    pub target: Option<Vec<u8>>,

    pub attributes: Option<crate::NodeAttributes2>,
}

impl SymlinkInfo {
    fn __max_ordinal(&self) -> usize {
        if self.target.is_some() {
            return 1;
        }

        if self.attributes.is_some() {
            return 2;
        }

        0
    }
}

impl ::fidl_next::Encodable for SymlinkInfo {
    type Encoded = WireSymlinkInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SymlinkInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSymlinkInfo { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(attributes) = &mut self.attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(target) = &mut self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireSymlinkInfo> for SymlinkInfo {
    #[inline]
    fn take_from(from: &WireSymlinkInfo) -> Self {
        Self {
            target: from.target().map(::fidl_next::TakeFrom::take_from),

            attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`SymlinkInfo`].
#[repr(C)]
pub struct WireSymlinkInfo {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireSymlinkInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSymlinkInfo
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireVector<u8>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireVector<u8>>()
                    };

                    if target.len() > 4095 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target.len() as u64,
                            limit: 4095,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeAttributes2>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireSymlinkInfo {
    pub fn target(&self) -> Option<&::fidl_next::WireVector<u8>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireSymlinkInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("SymlinkInfo")
            .field("target", &self.target())
            .field("attributes", &self.attributes())
            .finish()
    }
}

#[derive(Debug)]
pub enum Representation {
    Node(crate::NodeInfo),

    Directory(crate::DirectoryInfo),

    File(crate::FileInfo),

    Symlink(crate::SymlinkInfo),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Representation {
    type Encoded = WireRepresentation;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Representation
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRepresentation { raw } = out);

        match self {
            Self::Node(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::NodeInfo>(
                value, 1, encoder, raw,
            )?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DirectoryInfo,
            >(value, 2, encoder, raw)?,

            Self::File(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::FileInfo>(
                value, 3, encoder, raw,
            )?,

            Self::Symlink(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::SymlinkInfo>(
                    value, 4, encoder, raw,
                )?
            }

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Representation> {
    type EncodedOption = WireOptionalRepresentation;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<Representation>
where
    ___E: ?Sized,
    Representation: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalRepresentation { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRepresentation> for Representation {
    #[inline]
    fn take_from(from: &WireRepresentation) -> Self {
        match from.raw.ordinal() {
            1 => Self::Node(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireNodeInfo>()
            })),

            2 => Self::Directory(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirectoryInfo>()
            })),

            3 => Self::File(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireFileInfo>()
            })),

            4 => Self::Symlink(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireSymlinkInfo>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalRepresentation> for Option<Box<Representation>> {
    #[inline]
    fn take_from(from: &WireOptionalRepresentation) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`Representation`].
#[repr(transparent)]
pub struct WireRepresentation {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireRepresentation {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod representation {
    pub enum Ref<'union> {
        Node(&'union crate::WireNodeInfo),

        Directory(&'union crate::WireDirectoryInfo),

        File(&'union crate::WireFileInfo),

        Symlink(&'union crate::WireSymlinkInfo),

        UnknownOrdinal_(u64),
    }
}

impl WireRepresentation {
    pub fn as_ref(&self) -> crate::representation::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::representation::Ref::Node(unsafe {
                self.raw.get().deref_unchecked::<crate::WireNodeInfo>()
            }),

            2 => crate::representation::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirectoryInfo>()
            }),

            3 => crate::representation::Ref::File(unsafe {
                self.raw.get().deref_unchecked::<crate::WireFileInfo>()
            }),

            4 => crate::representation::Ref::Symlink(unsafe {
                self.raw.get().deref_unchecked::<crate::WireSymlinkInfo>()
            }),

            unknown => crate::representation::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireRepresentation
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireNodeInfo>(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryInfo>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileInfo>(raw, decoder)?,

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkInfo>(raw, decoder)?
            }

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireRepresentation {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireNodeInfo>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirectoryInfo>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireFileInfo>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireSymlinkInfo>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalRepresentation {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalRepresentation {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalRepresentation {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> Option<&WireRepresentation> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalRepresentation
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireNodeInfo>(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryInfo>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileInfo>(raw, decoder)?,

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkInfo>(raw, decoder)?
            }

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalRepresentation {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

::fidl_next::bitflags! {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
    )]
    pub struct NodeAttributesQuery: u64 {
        #[doc = " Requests [`NodeAttributes.protocols`].\n"]const PROTOCOLS = 1;
        #[doc = " Requests [`NodeAttributes.abilities`].\n"]const ABILITIES = 2;
        #[doc = " Requests [`NodeAttributes.content_size`].\n"]const CONTENT_SIZE = 4;
        #[doc = " Requests [`NodeAttributes.storage_size`].\n"]const STORAGE_SIZE = 8;
        #[doc = " Requests [`NodeAttributes.link_count`].\n"]const LINK_COUNT = 16;
        #[doc = " Requests [`NodeAttributes.id`].\n"]const ID = 32;
        #[doc = " Requests [`NodeAttributes.creation_time`].\n"]const CREATION_TIME = 64;
        #[doc = " Requests [`NodeAttributes.modification_time`].\n"]const MODIFICATION_TIME = 128;
        #[doc = " Posix attributes.\n"]const MODE = 256;
        const UID = 512;
        const GID = 1024;
        const RDEV = 2048;
        const ACCESS_TIME = 4096;
        const CHANGE_TIME = 8192;
        #[doc = " Verity attributes.\n"]const OPTIONS = 16384;
        const ROOT_HASH = 32768;
        const VERITY_ENABLED = 65536;
        #[doc = " Casefold (case-insensitive filename) support.\n When true, file lookups will be case-insensitive but case-preserving. i.e. \"Foo\" will\n be stored verbatim but can be opened as \"foo\", \"fOO\", etc. Casefolding is done in\n accordance to the Unicode 12 NFD normalization and casefolding standard.\n"]const CASEFOLD = 131072;
        #[doc = " Requests [`MutableNodeAttributes.selinux_context`]. See that field for more detail.\n"]const SELINUX_CONTEXT = 262144;
        #[doc = " fscrypt attribute.\n"]const WRAPPING_KEY_ID = 524288;
        #[doc = " When this is queried in [`fuchsia.io/Node.GetAttributes`], it indicates to the filesystem\n that this node has been accessed and is pending an access time update given that any one of\n the following conditions are met:\n   * current_access_time <= current_modification_time\n   * current_access_time <= current_change_time\n   * current_access_time < current_time - duration(1 day)\n\n If any of the above conditions are met, `access_time` is updated to the current time before\n any queried node attributes are returned.\n\n This is compatible with Linux relatime mount.\n\n The rationale behind adding this `NodeAttributesQuery` is that some filesystems, e.g. Fxfs,\n are unable to identify when a file access has occured and thus update the access time. We\n allow for clients to communicate to the underlying filesystem that a file access has\n occurred and that it awaits for an update to access time.\n\n WARNING: If this is queried without a prior file access, as long as the above conditions\n are met, the node\'s access time will be updated. Not all filesystems will support this. The\n query will be ignored if the filesystem does not support this.\n"]const PENDING_ACCESS_TIME_UPDATE = 1048576;
        const _ = !0;
    }
}

impl ::fidl_next::Encodable for NodeAttributesQuery {
    type Encoded = WireNodeAttributesQuery;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAttributesQuery
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeAttributesQuery { value } = out);
        let _ = value.write(::fidl_next::WireU64::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireNodeAttributesQuery> for NodeAttributesQuery {
    fn from(wire: WireNodeAttributesQuery) -> Self {
        Self::from_bits_retain(u64::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireNodeAttributesQuery> for NodeAttributesQuery {
    #[inline]
    fn take_from(from: &WireNodeAttributesQuery) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`NodeAttributesQuery`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireNodeAttributesQuery {
    value: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeAttributesQuery {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAttributesQuery
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<NodeAttributesQuery> for WireNodeAttributesQuery {
    fn from(natural: NodeAttributesQuery) -> Self {
        Self { value: ::fidl_next::WireU64::from(natural.bits()) }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct NodeGetAttributesRequest {
    pub query: crate::NodeAttributesQuery,
}

impl ::fidl_next::Encodable for NodeGetAttributesRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::NodeAttributesQuery as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    type Encoded = WireNodeGetAttributesRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeGetAttributesRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                query,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.query, encoder, query)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeGetAttributesRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeGetAttributesRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeGetAttributesRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetAttributesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeGetAttributesRequest> for NodeGetAttributesRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::NodeAttributesQuery as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireNodeGetAttributesRequest) -> Self {
        Self { query: ::fidl_next::TakeFrom::take_from(&from.query) }
    }
}

/// The wire type corresponding to [`NodeGetAttributesRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeGetAttributesRequest {
    pub query: crate::WireNodeAttributesQuery,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeGetAttributesRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeGetAttributesRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut query,

            } = slot;
        }

        ::fidl_next::Decode::decode(query.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Node protocol.
#[doc = " Node defines the minimal interface for entities which can be accessed in a filesystem.\n"]
#[derive(Debug)]
pub struct Node;

impl ::fidl_next::Discoverable for Node {
    const PROTOCOL_NAME: &'static str = "node";
}

pub mod node {
    pub mod prelude {
        pub use crate::{
            node, Node, NodeClientHandler, NodeClientSender, NodeServerHandler, NodeServerSender,
        };

        pub use crate::ConnectionInfo;

        pub use crate::ExtendedAttributeValue;

        pub use crate::MutableNodeAttributes;

        pub use crate::NodeAttributes2;

        pub use crate::NodeDeprecatedCloneRequest;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        pub use crate::NodeGetAttrResponse;

        pub use crate::NodeGetAttributesRequest;

        pub use crate::NodeGetExtendedAttributeRequest;

        pub use crate::NodeListExtendedAttributesRequest;

        pub use crate::NodeOnOpenRequest;

        pub use crate::NodeQueryFilesystemResponse;

        pub use crate::NodeRemoveExtendedAttributeRequest;

        pub use crate::NodeSetAttrRequest;

        pub use crate::NodeSetAttrResponse;

        pub use crate::NodeSetExtendedAttributeRequest;

        pub use crate::NodeSetFlagsRequest;

        pub use crate::NodeGetFlagsResponse;

        pub use crate::NodeRemoveExtendedAttributeResponse;

        pub use crate::NodeSetExtendedAttributeResponse;

        pub use crate::NodeSetFlagsResponse;

        pub use crate::NodeSyncResponse;

        pub use crate::NodeUpdateAttributesResponse;

        pub use crate::Representation;

        pub use ::fidl_next_fuchsia_unknown::CloneableCloneRequest;

        pub use ::fidl_next_fuchsia_unknown::CloseableCloseResponse;

        pub use ::fidl_next_fuchsia_unknown::QueryableQueryResponse;
    }

    pub struct Clone;

    impl ::fidl_next::Method for Clone {
        const ORDINAL: u64 = 2366825959783828089;

        type Protocol = crate::Node;

        type Request = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct Close;

    impl ::fidl_next::Method for Close {
        const ORDINAL: u64 = 6540867515453498750;

        type Protocol = crate::Node;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            ::fidl_next_fuchsia_unknown::WireCloseableCloseResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Query;

    impl ::fidl_next::Method for Query {
        const ORDINAL: u64 = 2763219980499352582;

        type Protocol = crate::Node;

        type Request = ();

        type Response = ::fidl_next_fuchsia_unknown::WireQueryableQueryResponse;
    }

    pub struct DeprecatedClone;

    impl ::fidl_next::Method for DeprecatedClone {
        const ORDINAL: u64 = 6512600400724287855;

        type Protocol = crate::Node;

        type Request = crate::WireNodeDeprecatedCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct OnOpen;

    impl ::fidl_next::Method for OnOpen {
        const ORDINAL: u64 = 9207534335756671346;

        type Protocol = crate::Node;

        type Request = ::fidl_next::Never;

        type Response = crate::WireNodeOnOpenRequest;
    }

    pub struct GetAttr;

    impl ::fidl_next::Method for GetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Node;

        type Request = ();

        type Response = crate::WireNodeGetAttrResponse;
    }

    pub struct SetAttr;

    impl ::fidl_next::Method for SetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Node;

        type Request = crate::WireNodeSetAttrRequest;

        type Response = crate::WireNodeSetAttrResponse;
    }

    pub struct DeprecatedGetFlags;

    impl ::fidl_next::Method for DeprecatedGetFlags {
        const ORDINAL: u64 = 6595803110182632097;

        type Protocol = crate::Node;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetFlagsResponse;
    }

    pub struct DeprecatedSetFlags;

    impl ::fidl_next::Method for DeprecatedSetFlags {
        const ORDINAL: u64 = 5950864159036794675;

        type Protocol = crate::Node;

        type Request = crate::WireNodeDeprecatedSetFlagsRequest;

        type Response = crate::WireNodeDeprecatedSetFlagsResponse;
    }

    pub struct GetFlags;

    impl ::fidl_next::Method for GetFlags {
        const ORDINAL: u64 = 105530239381466147;

        type Protocol = crate::Node;

        type Request = ();

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeGetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct SetFlags;

    impl ::fidl_next::Method for SetFlags {
        const ORDINAL: u64 = 6172186066099445416;

        type Protocol = crate::Node;

        type Request = crate::WireNodeSetFlagsRequest;

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeSetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct QueryFilesystem;

    impl ::fidl_next::Method for QueryFilesystem {
        const ORDINAL: u64 = 8013111122914313744;

        type Protocol = crate::Node;

        type Request = ();

        type Response = crate::WireNodeQueryFilesystemResponse;
    }

    pub struct OnRepresentation;

    impl ::fidl_next::Method for OnRepresentation {
        const ORDINAL: u64 = 6679970090861613324;

        type Protocol = crate::Node;

        type Request = ::fidl_next::Never;

        type Response = crate::WireRepresentation;
    }

    pub struct GetConnectionInfo;

    impl ::fidl_next::Method for GetConnectionInfo {
        const ORDINAL: u64 = 6362521381364198667;

        type Protocol = crate::Node;

        type Request = ();

        type Response = crate::WireConnectionInfo;
    }

    pub struct GetAttributes;

    impl ::fidl_next::Method for GetAttributes {
        const ORDINAL: u64 = 4414537700416816443;

        type Protocol = crate::Node;

        type Request = crate::WireNodeGetAttributesRequest;

        type Response = ::fidl_next::WireResult<crate::WireNodeAttributes2, ::fidl_next::WireI32>;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Node;

        type Request = crate::WireMutableNodeAttributes;

        type Response =
            ::fidl_next::WireResult<crate::WireNodeUpdateAttributesResponse, ::fidl_next::WireI32>;
    }

    pub struct Sync;

    impl ::fidl_next::Method for Sync {
        const ORDINAL: u64 = 3196473584242777161;

        type Protocol = crate::Node;

        type Request = ();

        type Response = ::fidl_next::WireResult<crate::WireNodeSyncResponse, ::fidl_next::WireI32>;
    }

    pub struct ListExtendedAttributes;

    impl ::fidl_next::Method for ListExtendedAttributes {
        const ORDINAL: u64 = 5431626189872037072;

        type Protocol = crate::Node;

        type Request = crate::WireNodeListExtendedAttributesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct GetExtendedAttribute;

    impl ::fidl_next::Method for GetExtendedAttribute {
        const ORDINAL: u64 = 5043930208506967771;

        type Protocol = crate::Node;

        type Request = crate::WireNodeGetExtendedAttributeRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireExtendedAttributeValue, ::fidl_next::WireI32>;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Node;

        type Request = crate::WireNodeSetExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeSetExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct RemoveExtendedAttribute;

    impl ::fidl_next::Method for RemoveExtendedAttribute {
        const ORDINAL: u64 = 8794297771444732717;

        type Protocol = crate::Node;

        type Request = crate::WireNodeRemoveExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeRemoveExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }
}

/// A helper trait for the `Node` client sender.
pub trait NodeClientSender {
    type Transport: ::fidl_next::Transport;

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Close>,
        ::fidl_next::EncodeError,
    >;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Query>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >;

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetAttr>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >;

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::QueryFilesystem>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >;

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >;

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Sync>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >;

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >;

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >;

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >;
}

impl<___T> NodeClientSender for ::fidl_next::ClientSender<___T, Node>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(2366825959783828089, request)
    }

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Close>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6540867515453498750, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Query>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2763219980499352582, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(6512600400724287855, request)
    }

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetAttr>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8689798978500614909, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4721673413776871238, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6595803110182632097, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5950864159036794675, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(105530239381466147, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6172186066099445416, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::QueryFilesystem>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8013111122914313744, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6362521381364198667, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4414537700416816443, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >,
    {
        self.as_untyped()
            .send_two_way(3677402239314018056, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::Sync>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(3196473584242777161, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >,
    {
        self.as_untyped().send_one_way(5431626189872037072, request)
    }

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5043930208506967771, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5374223046099989052, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8794297771444732717, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Node protocol.
///
/// See [`Node`] for more details.
pub trait NodeClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
    fn on_open(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Node>,

        message: ::fidl_next::ResponseBuffer<___T, node::OnOpen>,
    );

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
    fn on_representation(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Node>,

        message: ::fidl_next::ResponseBuffer<___T, node::OnRepresentation>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Node>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Node
where
    ___T: ::fidl_next::Transport,
    ___H: NodeClientHandler<___T>,

    <node::Close as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::Query as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::OnOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::SetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedGetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedSetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::SetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::QueryFilesystem as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::OnRepresentation as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetConnectionInfo as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::UpdateAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::Sync as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::SetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::RemoveExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_open(sender, buffer);
            }

            6679970090861613324 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_representation(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `Node` server sender.
pub trait NodeServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node::OnOpen as ::fidl_next::Method>::Response,
        >;

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node::OnRepresentation as ::fidl_next::Method>::Response,
        >;
}

impl<___T> NodeServerSender for ::fidl_next::ServerSender<___T, Node>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node::OnOpen as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(9207534335756671346, request)
    }

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node::OnRepresentation as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(6679970090861613324, request)
    }
}

/// A server handler for the Node protocol.
///
/// See [`Node`] for more details.
pub trait NodeServerHandler<___T: ::fidl_next::Transport> {
    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::Clone>,
    );

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::Close>,
    );

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::Query>,
    );

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::DeprecatedClone>,
    );

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::GetAttr>,
    );

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::SetAttr>,

        responder: ::fidl_next::Responder<node::SetAttr>,
    );

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::DeprecatedGetFlags>,
    );

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::DeprecatedSetFlags>,

        responder: ::fidl_next::Responder<node::DeprecatedSetFlags>,
    );

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::GetFlags>,
    );

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::SetFlags>,

        responder: ::fidl_next::Responder<node::SetFlags>,
    );

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::QueryFilesystem>,
    );

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::GetConnectionInfo>,
    );

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::GetAttributes>,

        responder: ::fidl_next::Responder<node::GetAttributes>,
    );

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::UpdateAttributes>,

        responder: ::fidl_next::Responder<node::UpdateAttributes>,
    );

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        responder: ::fidl_next::Responder<node::Sync>,
    );

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::ListExtendedAttributes>,
    );

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::GetExtendedAttribute>,

        responder: ::fidl_next::Responder<node::GetExtendedAttribute>,
    );

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::SetExtendedAttribute>,

        responder: ::fidl_next::Responder<node::SetExtendedAttribute>,
    );

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::RequestBuffer<___T, node::RemoveExtendedAttribute>,

        responder: ::fidl_next::Responder<node::RemoveExtendedAttribute>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Node
where
    ___T: ::fidl_next::Transport,
    ___H: NodeServerHandler<___T>,

    ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetAttrRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireMutableNodeAttributes:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeListExtendedAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeRemoveExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.clone(sender, buffer);
            }

            6512600400724287855 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_clone(sender, buffer);
            }

            5431626189872037072 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.list_extended_attributes(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder);
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder);
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_attr(sender, responder);
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_attr(sender, buffer, responder);
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder);
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_set_flags(sender, buffer, responder);
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder);
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_flags(sender, buffer, responder);
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder);
            }

            6362521381364198667 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_connection_info(sender, responder);
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_attributes(sender, buffer, responder);
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.update_attributes(sender, buffer, responder);
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder);
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_extended_attribute(sender, buffer, responder);
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_extended_attribute(sender, buffer, responder);
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.remove_extended_attribute(sender, buffer, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub struct DirectoryDeprecatedOpenRequest {
    pub flags: crate::OpenFlags,

    pub mode: crate::ModeType,

    pub path: String,

    pub object: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Node>,
}

impl ::fidl_next::Encodable for DirectoryDeprecatedOpenRequest {
    type Encoded = WireDirectoryDeprecatedOpenRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryDeprecatedOpenRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,
                mode,
                path,
                object,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        ::fidl_next::Encode::encode(&mut self.mode, encoder, mode)?;

        ::fidl_next::Encode::encode(&mut self.path, encoder, path)?;

        ::fidl_next::Encode::encode(&mut self.object, encoder, object)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryDeprecatedOpenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryDeprecatedOpenRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryDeprecatedOpenRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryDeprecatedOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryDeprecatedOpenRequest> for DirectoryDeprecatedOpenRequest {
    #[inline]
    fn take_from(from: &WireDirectoryDeprecatedOpenRequest) -> Self {
        Self {
            flags: ::fidl_next::TakeFrom::take_from(&from.flags),

            mode: ::fidl_next::TakeFrom::take_from(&from.mode),

            path: ::fidl_next::TakeFrom::take_from(&from.path),

            object: ::fidl_next::TakeFrom::take_from(&from.object),
        }
    }
}

/// The wire type corresponding to [`DirectoryDeprecatedOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryDeprecatedOpenRequest {
    pub flags: crate::WireOpenFlags,

    pub mode: crate::WireModeType,

    pub path: ::fidl_next::WireString,

    pub object: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Node>,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryDeprecatedOpenRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryDeprecatedOpenRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,
                mut mode,
                mut path,
                mut object,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(mode.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(path.as_mut(), decoder)?;

        let path = unsafe { path.deref_unchecked() };

        if path.len() > 4095 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: path.len() as u64,
                limit: 4095,
            });
        }

        ::fidl_next::Decode::decode(object.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " Options which can be used when opening nodes. Unlike [`Flags`], these options are designed for\n specific use cases (e.g. to reduce round-trip latency when requesting attributes).\n"]
#[derive(Clone, Debug)]
pub struct Options {
    pub attributes: Option<crate::NodeAttributesQuery>,

    pub create_attributes: Option<crate::MutableNodeAttributes>,
}

impl Options {
    fn __max_ordinal(&self) -> usize {
        if self.attributes.is_some() {
            return 1;
        }

        if self.create_attributes.is_some() {
            return 2;
        }

        0
    }
}

impl ::fidl_next::Encodable for Options {
    type Encoded = WireOptions;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Options
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptions { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(create_attributes) = &mut self.create_attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            create_attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(attributes) = &mut self.attributes {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireOptions> for Options {
    #[inline]
    fn take_from(from: &WireOptions) -> Self {
        Self {
            attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

            create_attributes: from.create_attributes().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`Options`].
#[repr(C)]
pub struct WireOptions {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptions {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptions
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireNodeAttributesQuery>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireMutableNodeAttributes>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireOptions {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributesQuery> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn create_attributes(&self) -> Option<&crate::WireMutableNodeAttributes> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Options")
            .field("attributes", &self.attributes())
            .field("create_attributes", &self.create_attributes())
            .finish()
    }
}

#[derive(Debug)]
pub struct DirectoryOpenRequest {
    pub path: String,

    pub flags: crate::Flags,

    pub options: crate::Options,

    pub object: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for DirectoryOpenRequest {
    type Encoded = WireDirectoryOpenRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryOpenRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                path,
                flags,
                options,
                object,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.path, encoder, path)?;

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        ::fidl_next::Encode::encode(&mut self.options, encoder, options)?;

        ::fidl_next::Encode::encode(&mut self.object, encoder, object)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryOpenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryOpenRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryOpenRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryOpenRequest> for DirectoryOpenRequest {
    #[inline]
    fn take_from(from: &WireDirectoryOpenRequest) -> Self {
        Self {
            path: ::fidl_next::TakeFrom::take_from(&from.path),

            flags: ::fidl_next::TakeFrom::take_from(&from.flags),

            options: ::fidl_next::TakeFrom::take_from(&from.options),

            object: ::fidl_next::TakeFrom::take_from(&from.object),
        }
    }
}

/// The wire type corresponding to [`DirectoryOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryOpenRequest {
    pub path: ::fidl_next::WireString,

    pub flags: crate::WireFlags,

    pub options: crate::WireOptions,

    pub object: ::fidl_next::fuchsia::WireHandle,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryOpenRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryOpenRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut path,
                mut flags,
                mut options,
                mut object,

            } = slot;
        }

        ::fidl_next::Decode::decode(path.as_mut(), decoder)?;

        let path = unsafe { path.deref_unchecked() };

        if path.len() > 4095 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: path.len() as u64,
                limit: 4095,
            });
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(options.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(object.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Debug)]
pub struct DirectoryCreateSymlinkRequest {
    pub name: String,

    pub target: Vec<u8>,

    pub connection:
        ::fidl_next::ServerEnd<Option<::fidl_next::fuchsia::zx::Channel>, crate::Symlink>,
}

impl ::fidl_next::Encodable for DirectoryCreateSymlinkRequest {
    type Encoded = WireDirectoryCreateSymlinkRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryCreateSymlinkRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                name,
                target,
                connection,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        ::fidl_next::Encode::encode(&mut self.target, encoder, target)?;

        ::fidl_next::Encode::encode(&mut self.connection, encoder, connection)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryCreateSymlinkRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryCreateSymlinkRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryCreateSymlinkRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryCreateSymlinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryCreateSymlinkRequest> for DirectoryCreateSymlinkRequest {
    #[inline]
    fn take_from(from: &WireDirectoryCreateSymlinkRequest) -> Self {
        Self {
            name: ::fidl_next::TakeFrom::take_from(&from.name),

            target: ::fidl_next::TakeFrom::take_from(&from.target),

            connection: ::fidl_next::TakeFrom::take_from(&from.connection),
        }
    }
}

/// The wire type corresponding to [`DirectoryCreateSymlinkRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryCreateSymlinkRequest {
    pub name: ::fidl_next::WireString,

    pub target: ::fidl_next::WireVector<u8>,

    pub connection:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireOptionalChannel, crate::Symlink>,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryCreateSymlinkRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryCreateSymlinkRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut name,
                mut target,
                mut connection,

            } = slot;
        }

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        let name = unsafe { name.deref_unchecked() };

        if name.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: name.len() as u64,
                limit: 255,
            });
        }

        ::fidl_next::Decode::decode(target.as_mut(), decoder)?;

        let target = unsafe { target.deref_unchecked() };

        if target.len() > 4095 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: target.len() as u64,
                limit: 4095,
            });
        }

        ::fidl_next::Decode::decode(connection.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Directory protocol.
#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
#[derive(Debug)]
pub struct Directory;

impl ::fidl_next::Discoverable for Directory {
    const PROTOCOL_NAME: &'static str = "directory";
}

pub mod directory {
    pub mod prelude {
        pub use crate::{
            directory, Directory, DirectoryClientHandler, DirectoryClientSender,
            DirectoryServerHandler, DirectoryServerSender,
        };

        pub use crate::AdvisoryLockingAdvisoryLockRequest;

        pub use crate::AdvisoryLockingAdvisoryLockResponse;

        pub use crate::ConnectionInfo;

        pub use crate::DirectoryCreateSymlinkRequest;

        pub use crate::DirectoryDeprecatedOpenRequest;

        pub use crate::DirectoryGetTokenResponse;

        pub use crate::DirectoryLinkRequest;

        pub use crate::DirectoryLinkResponse;

        pub use crate::DirectoryOpenRequest;

        pub use crate::DirectoryReadDirentsRequest;

        pub use crate::DirectoryReadDirentsResponse;

        pub use crate::DirectoryRenameRequest;

        pub use crate::DirectoryRewindResponse;

        pub use crate::DirectoryUnlinkRequest;

        pub use crate::DirectoryWatchRequest;

        pub use crate::DirectoryWatchResponse;

        pub use crate::DirectoryCreateSymlinkResponse;

        pub use crate::DirectoryRenameResponse;

        pub use crate::DirectoryUnlinkResponse;

        pub use crate::ExtendedAttributeValue;

        pub use crate::MutableNodeAttributes;

        pub use crate::NodeAttributes2;

        pub use crate::NodeDeprecatedCloneRequest;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        pub use crate::NodeGetAttrResponse;

        pub use crate::NodeGetAttributesRequest;

        pub use crate::NodeGetExtendedAttributeRequest;

        pub use crate::NodeListExtendedAttributesRequest;

        pub use crate::NodeOnOpenRequest;

        pub use crate::NodeQueryFilesystemResponse;

        pub use crate::NodeRemoveExtendedAttributeRequest;

        pub use crate::NodeSetAttrRequest;

        pub use crate::NodeSetAttrResponse;

        pub use crate::NodeSetExtendedAttributeRequest;

        pub use crate::NodeSetFlagsRequest;

        pub use crate::NodeGetFlagsResponse;

        pub use crate::NodeRemoveExtendedAttributeResponse;

        pub use crate::NodeSetExtendedAttributeResponse;

        pub use crate::NodeSetFlagsResponse;

        pub use crate::NodeSyncResponse;

        pub use crate::NodeUpdateAttributesResponse;

        pub use crate::Representation;

        pub use ::fidl_next_fuchsia_unknown::CloneableCloneRequest;

        pub use ::fidl_next_fuchsia_unknown::CloseableCloseResponse;

        pub use ::fidl_next_fuchsia_unknown::QueryableQueryResponse;
    }

    pub struct AdvisoryLock;

    impl ::fidl_next::Method for AdvisoryLock {
        const ORDINAL: u64 = 7992130864415541162;

        type Protocol = crate::Directory;

        type Request = crate::WireAdvisoryLockingAdvisoryLockRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireAdvisoryLockingAdvisoryLockResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Clone;

    impl ::fidl_next::Method for Clone {
        const ORDINAL: u64 = 2366825959783828089;

        type Protocol = crate::Directory;

        type Request = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct Close;

    impl ::fidl_next::Method for Close {
        const ORDINAL: u64 = 6540867515453498750;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            ::fidl_next_fuchsia_unknown::WireCloseableCloseResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Query;

    impl ::fidl_next::Method for Query {
        const ORDINAL: u64 = 2763219980499352582;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = ::fidl_next_fuchsia_unknown::WireQueryableQueryResponse;
    }

    pub struct DeprecatedClone;

    impl ::fidl_next::Method for DeprecatedClone {
        const ORDINAL: u64 = 6512600400724287855;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeDeprecatedCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct OnOpen;

    impl ::fidl_next::Method for OnOpen {
        const ORDINAL: u64 = 9207534335756671346;

        type Protocol = crate::Directory;

        type Request = ::fidl_next::Never;

        type Response = crate::WireNodeOnOpenRequest;
    }

    pub struct GetAttr;

    impl ::fidl_next::Method for GetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireNodeGetAttrResponse;
    }

    pub struct SetAttr;

    impl ::fidl_next::Method for SetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeSetAttrRequest;

        type Response = crate::WireNodeSetAttrResponse;
    }

    pub struct DeprecatedGetFlags;

    impl ::fidl_next::Method for DeprecatedGetFlags {
        const ORDINAL: u64 = 6595803110182632097;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetFlagsResponse;
    }

    pub struct DeprecatedSetFlags;

    impl ::fidl_next::Method for DeprecatedSetFlags {
        const ORDINAL: u64 = 5950864159036794675;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeDeprecatedSetFlagsRequest;

        type Response = crate::WireNodeDeprecatedSetFlagsResponse;
    }

    pub struct GetFlags;

    impl ::fidl_next::Method for GetFlags {
        const ORDINAL: u64 = 105530239381466147;

        type Protocol = crate::Directory;

        type Request = ();

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeGetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct SetFlags;

    impl ::fidl_next::Method for SetFlags {
        const ORDINAL: u64 = 6172186066099445416;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeSetFlagsRequest;

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeSetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct QueryFilesystem;

    impl ::fidl_next::Method for QueryFilesystem {
        const ORDINAL: u64 = 8013111122914313744;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireNodeQueryFilesystemResponse;
    }

    pub struct OnRepresentation;

    impl ::fidl_next::Method for OnRepresentation {
        const ORDINAL: u64 = 6679970090861613324;

        type Protocol = crate::Directory;

        type Request = ::fidl_next::Never;

        type Response = crate::WireRepresentation;
    }

    pub struct GetConnectionInfo;

    impl ::fidl_next::Method for GetConnectionInfo {
        const ORDINAL: u64 = 6362521381364198667;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireConnectionInfo;
    }

    pub struct GetAttributes;

    impl ::fidl_next::Method for GetAttributes {
        const ORDINAL: u64 = 4414537700416816443;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeGetAttributesRequest;

        type Response = ::fidl_next::WireResult<crate::WireNodeAttributes2, ::fidl_next::WireI32>;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Directory;

        type Request = crate::WireMutableNodeAttributes;

        type Response =
            ::fidl_next::WireResult<crate::WireNodeUpdateAttributesResponse, ::fidl_next::WireI32>;
    }

    pub struct Sync;

    impl ::fidl_next::Method for Sync {
        const ORDINAL: u64 = 3196473584242777161;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = ::fidl_next::WireResult<crate::WireNodeSyncResponse, ::fidl_next::WireI32>;
    }

    pub struct ListExtendedAttributes;

    impl ::fidl_next::Method for ListExtendedAttributes {
        const ORDINAL: u64 = 5431626189872037072;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeListExtendedAttributesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct GetExtendedAttribute;

    impl ::fidl_next::Method for GetExtendedAttribute {
        const ORDINAL: u64 = 5043930208506967771;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeGetExtendedAttributeRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireExtendedAttributeValue, ::fidl_next::WireI32>;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeSetExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeSetExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct RemoveExtendedAttribute;

    impl ::fidl_next::Method for RemoveExtendedAttribute {
        const ORDINAL: u64 = 8794297771444732717;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeRemoveExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeRemoveExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct DeprecatedOpen;

    impl ::fidl_next::Method for DeprecatedOpen {
        const ORDINAL: u64 = 3193127272456937152;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryDeprecatedOpenRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct Open;

    impl ::fidl_next::Method for Open {
        const ORDINAL: u64 = 6236883748953765593;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryOpenRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct ReadDirents;

    impl ::fidl_next::Method for ReadDirents {
        const ORDINAL: u64 = 3855785432100874762;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryReadDirentsRequest;

        type Response = crate::WireDirectoryReadDirentsResponse;
    }

    pub struct Rewind;

    impl ::fidl_next::Method for Rewind {
        const ORDINAL: u64 = 1635123508515392625;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireDirectoryRewindResponse;
    }

    pub struct GetToken;

    impl ::fidl_next::Method for GetToken {
        const ORDINAL: u64 = 2787337947777369685;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireDirectoryGetTokenResponse;
    }

    pub struct Link;

    impl ::fidl_next::Method for Link {
        const ORDINAL: u64 = 8360374984291987687;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryLinkRequest;

        type Response = crate::WireDirectoryLinkResponse;
    }

    pub struct Unlink;

    impl ::fidl_next::Method for Unlink {
        const ORDINAL: u64 = 8433556716759383021;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryUnlinkRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireDirectoryUnlinkResponse, ::fidl_next::WireI32>;
    }

    pub struct Rename;

    impl ::fidl_next::Method for Rename {
        const ORDINAL: u64 = 8097726607824333022;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryRenameRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireDirectoryRenameResponse, ::fidl_next::WireI32>;
    }

    pub struct CreateSymlink;

    impl ::fidl_next::Method for CreateSymlink {
        const ORDINAL: u64 = 2435901052462315657;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryCreateSymlinkRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireDirectoryCreateSymlinkResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Watch;

    impl ::fidl_next::Method for Watch {
        const ORDINAL: u64 = 6275512344170098065;

        type Protocol = crate::Directory;

        type Request = crate::WireDirectoryWatchRequest;

        type Response = crate::WireDirectoryWatchResponse;
    }
}

/// A helper trait for the `Directory` client sender.
pub trait DirectoryClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >;

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Close>,
        ::fidl_next::EncodeError,
    >;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Query>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >;

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetAttr>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >;

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::QueryFilesystem>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >;

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >;

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Sync>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >;

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >;

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >;

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >;

    #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
    fn deprecated_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryDeprecatedOpenRequest,
        >;

    #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
    fn open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryOpenRequest,
        >;

    #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n   // Describes the inode of the entry.\n   uint64 ino;\n   // Describes the length of the dirent name in bytes.\n   uint8 size;\n   // Describes the type of the entry. Aligned with the\n   // POSIX d_type values. Use `DirentType` constants.\n   uint8 type;\n   // Unterminated name of entry.\n   char name[0];\n }\n ```\n\n This method does not require any rights, since one could always probe for\n directory contents by triggering name conflicts during file creation.\n"]
    fn read_dirents<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::ReadDirents>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryReadDirentsRequest,
        >;

    #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn rewind(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Rewind>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn get_token(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetToken>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
    fn link<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Link>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryLinkRequest,
        >;

    #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n   [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n   support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n   containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n     something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
    fn unlink<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Unlink>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryUnlinkRequest,
        >;

    #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
    fn rename<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Rename>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryRenameRequest,
        >;

    #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
    fn create_symlink<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::CreateSymlink>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryCreateSymlinkRequest,
        >;

    #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn watch<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Watch>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryWatchRequest,
        >;
}

impl<___T> DirectoryClientSender for ::fidl_next::ClientSender<___T, Directory>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7992130864415541162, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(2366825959783828089, request)
    }

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Close>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6540867515453498750, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Query>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2763219980499352582, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(6512600400724287855, request)
    }

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetAttr>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8689798978500614909, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4721673413776871238, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6595803110182632097, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5950864159036794675, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(105530239381466147, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6172186066099445416, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::QueryFilesystem>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8013111122914313744, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6362521381364198667, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4414537700416816443, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >,
    {
        self.as_untyped()
            .send_two_way(3677402239314018056, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Sync>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(3196473584242777161, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >,
    {
        self.as_untyped().send_one_way(5431626189872037072, request)
    }

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5043930208506967771, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5374223046099989052, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8794297771444732717, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
    fn deprecated_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryDeprecatedOpenRequest,
        >,
    {
        self.as_untyped().send_one_way(3193127272456937152, request)
    }

    #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
    fn open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryOpenRequest,
        >,
    {
        self.as_untyped().send_one_way(6236883748953765593, request)
    }

    #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n   // Describes the inode of the entry.\n   uint64 ino;\n   // Describes the length of the dirent name in bytes.\n   uint8 size;\n   // Describes the type of the entry. Aligned with the\n   // POSIX d_type values. Use `DirentType` constants.\n   uint8 type;\n   // Unterminated name of entry.\n   char name[0];\n }\n ```\n\n This method does not require any rights, since one could always probe for\n directory contents by triggering name conflicts during file creation.\n"]
    fn read_dirents<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::ReadDirents>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryReadDirentsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(3855785432100874762, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn rewind(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Rewind>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(1635123508515392625, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn get_token(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::GetToken>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2787337947777369685, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
    fn link<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Link>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryLinkRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8360374984291987687, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n   [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n   support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n   containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n     something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
    fn unlink<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Unlink>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryUnlinkRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8433556716759383021, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
    fn rename<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Rename>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryRenameRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8097726607824333022, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
    fn create_symlink<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::CreateSymlink>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryCreateSymlinkRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(2435901052462315657, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn watch<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory::Watch>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirectoryWatchRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6275512344170098065, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Directory protocol.
///
/// See [`Directory`] for more details.
pub trait DirectoryClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
    fn on_open(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Directory>,

        message: ::fidl_next::ResponseBuffer<___T, directory::OnOpen>,
    );

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
    fn on_representation(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Directory>,

        message: ::fidl_next::ResponseBuffer<___T, directory::OnRepresentation>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Directory>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Directory
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryClientHandler<___T>,

    <directory::AdvisoryLock as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Close as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Query as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::OnOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::SetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedGetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedSetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::SetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::QueryFilesystem as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::OnRepresentation as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetConnectionInfo as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::UpdateAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Sync as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::SetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::RemoveExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::ReadDirents as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Rewind as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetToken as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Link as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Unlink as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Rename as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::CreateSymlink as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Watch as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_open(sender, buffer);
            }

            6679970090861613324 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_representation(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `Directory` server sender.
pub trait DirectoryServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <directory::OnOpen as ::fidl_next::Method>::Response,
        >;

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <directory::OnRepresentation as ::fidl_next::Method>::Response,
        >;
}

impl<___T> DirectoryServerSender for ::fidl_next::ServerSender<___T, Directory>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <directory::OnOpen as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(9207534335756671346, request)
    }

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <directory::OnRepresentation as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(6679970090861613324, request)
    }
}

/// A server handler for the Directory protocol.
///
/// See [`Directory`] for more details.
pub trait DirectoryServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::AdvisoryLock>,

        responder: ::fidl_next::Responder<directory::AdvisoryLock>,
    );

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::Clone>,
    );

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::Close>,
    );

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::Query>,
    );

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::DeprecatedClone>,
    );

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::GetAttr>,
    );

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::SetAttr>,

        responder: ::fidl_next::Responder<directory::SetAttr>,
    );

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::DeprecatedGetFlags>,
    );

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::DeprecatedSetFlags>,

        responder: ::fidl_next::Responder<directory::DeprecatedSetFlags>,
    );

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::GetFlags>,
    );

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::SetFlags>,

        responder: ::fidl_next::Responder<directory::SetFlags>,
    );

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::QueryFilesystem>,
    );

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::GetConnectionInfo>,
    );

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::GetAttributes>,

        responder: ::fidl_next::Responder<directory::GetAttributes>,
    );

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::UpdateAttributes>,

        responder: ::fidl_next::Responder<directory::UpdateAttributes>,
    );

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::Sync>,
    );

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::ListExtendedAttributes>,
    );

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::GetExtendedAttribute>,

        responder: ::fidl_next::Responder<directory::GetExtendedAttribute>,
    );

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::SetExtendedAttribute>,

        responder: ::fidl_next::Responder<directory::SetExtendedAttribute>,
    );

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::RemoveExtendedAttribute>,

        responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute>,
    );

    #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
    fn deprecated_open(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::DeprecatedOpen>,
    );

    #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
    fn open(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::Open>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, directory::ReadDirents>,

        responder: ::fidl_next::Responder<directory::ReadDirents>,
    );

    #[doc = " Resets the directory seek offset.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn rewind(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::Rewind>,
    );

    #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn get_token(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        responder: ::fidl_next::Responder<directory::GetToken>,
    );

    #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
    fn link(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::Link>,

        responder: ::fidl_next::Responder<directory::Link>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, directory::Unlink>,

        responder: ::fidl_next::Responder<directory::Unlink>,
    );

    #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
    fn rename(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::Rename>,

        responder: ::fidl_next::Responder<directory::Rename>,
    );

    #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
    fn create_symlink(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::CreateSymlink>,

        responder: ::fidl_next::Responder<directory::CreateSymlink>,
    );

    #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method does not require any rights, similar to ReadDirents.\n"]
    fn watch(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,

        request: ::fidl_next::RequestBuffer<___T, directory::Watch>,

        responder: ::fidl_next::Responder<directory::Watch>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Directory>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Directory
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryServerHandler<___T>,

    crate::WireAdvisoryLockingAdvisoryLockRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetAttrRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireMutableNodeAttributes:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeListExtendedAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeRemoveExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryDeprecatedOpenRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryOpenRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryReadDirentsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryLinkRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryUnlinkRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryRenameRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryCreateSymlinkRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireDirectoryWatchRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.clone(sender, buffer);
            }

            6512600400724287855 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_clone(sender, buffer);
            }

            5431626189872037072 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.list_extended_attributes(sender, buffer);
            }

            3193127272456937152 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_open(sender, buffer);
            }

            6236883748953765593 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.open(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            7992130864415541162 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.advisory_lock(sender, buffer, responder);
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder);
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder);
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_attr(sender, responder);
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_attr(sender, buffer, responder);
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder);
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_set_flags(sender, buffer, responder);
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder);
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_flags(sender, buffer, responder);
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder);
            }

            6362521381364198667 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_connection_info(sender, responder);
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_attributes(sender, buffer, responder);
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.update_attributes(sender, buffer, responder);
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder);
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_extended_attribute(sender, buffer, responder);
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_extended_attribute(sender, buffer, responder);
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.remove_extended_attribute(sender, buffer, responder);
            }

            3855785432100874762 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.read_dirents(sender, buffer, responder);
            }

            1635123508515392625 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.rewind(sender, responder);
            }

            2787337947777369685 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_token(sender, responder);
            }

            8360374984291987687 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.link(sender, buffer, responder);
            }

            8433556716759383021 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.unlink(sender, buffer, responder);
            }

            8097726607824333022 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.rename(sender, buffer, responder);
            }

            2435901052462315657 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.create_symlink(sender, buffer, responder);
            }

            6275512344170098065 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.watch(sender, buffer, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryObject {}

impl ::fidl_next::Encodable for DirectoryObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    type Encoded = WireDirectoryObject;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryObject
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryObject> {
    type EncodedOption = ::fidl_next::WireBox<WireDirectoryObject>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DirectoryObject>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryObject> for DirectoryObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn take_from(from: &WireDirectoryObject) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`DirectoryObject`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDirectoryObject {}

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryObject {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryObject
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

            } = slot;
        }

        Ok(())
    }
}

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

pub mod directory_watcher {
    pub mod prelude {
        pub use crate::{
            directory_watcher, DirectoryWatcher, DirectoryWatcherClientHandler,
            DirectoryWatcherClientSender, DirectoryWatcherServerHandler,
            DirectoryWatcherServerSender,
        };
    }
}

/// A helper trait for the `DirectoryWatcher` client sender.
pub trait DirectoryWatcherClientSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> DirectoryWatcherClientSender for ::fidl_next::ClientSender<___T, DirectoryWatcher>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A client handler for the DirectoryWatcher protocol.
///
/// See [`DirectoryWatcher`] for more details.
pub trait DirectoryWatcherClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DirectoryWatcher
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryWatcherClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `DirectoryWatcher` server sender.
pub trait DirectoryWatcherServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> DirectoryWatcherServerSender for ::fidl_next::ServerSender<___T, DirectoryWatcher>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the DirectoryWatcher protocol.
///
/// See [`DirectoryWatcher`] for more details.
pub trait DirectoryWatcherServerHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DirectoryWatcher
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryWatcherServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum DirentType {
    Unknown = 0,
    Directory = 4,
    BlockDevice = 6,
    File = 8,
    Symlink = 10,
    Service = 16,
    UnknownOrdinal_(u8),
}

impl ::fidl_next::Encodable for DirentType {
    type Encoded = WireDirentType;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirentType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDirentType { value } = out);
        let _ = value.write(u8::from(match *self {
            Self::Unknown => 0,

            Self::Directory => 4,

            Self::BlockDevice => 6,

            Self::File => 8,

            Self::Symlink => 10,

            Self::Service => 16,

            Self::UnknownOrdinal_(value) => value,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireDirentType> for DirentType {
    fn from(wire: WireDirentType) -> Self {
        match u8::from(wire.value) {
            0 => Self::Unknown,

            4 => Self::Directory,

            6 => Self::BlockDevice,

            8 => Self::File,

            10 => Self::Symlink,

            16 => Self::Service,

            value => Self::UnknownOrdinal_(value),
        }
    }
}

impl ::fidl_next::TakeFrom<WireDirentType> for DirentType {
    #[inline]
    fn take_from(from: &WireDirentType) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`DirentType`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireDirentType {
    value: u8,
}

unsafe impl ::fidl_next::ZeroPadding for WireDirentType {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireDirentType {
    pub const UNKNOWN: WireDirentType = WireDirentType { value: 0 };

    pub const DIRECTORY: WireDirentType = WireDirentType { value: 4 };

    pub const BLOCK_DEVICE: WireDirentType = WireDirentType { value: 6 };

    pub const FILE: WireDirentType = WireDirentType { value: 8 };

    pub const SYMLINK: WireDirentType = WireDirentType { value: 10 };

    pub const SERVICE: WireDirentType = WireDirentType { value: 16 };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirentType
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<DirentType> for WireDirentType {
    fn from(natural: DirentType) -> Self {
        match natural {
            DirentType::Unknown => WireDirentType::UNKNOWN,

            DirentType::Directory => WireDirentType::DIRECTORY,

            DirentType::BlockDevice => WireDirentType::BLOCK_DEVICE,

            DirentType::File => WireDirentType::FILE,

            DirentType::Symlink => WireDirentType::SYMLINK,

            DirentType::Service => WireDirentType::SERVICE,

            DirentType::UnknownOrdinal_(value) => WireDirentType { value: u8::from(value) },
        }
    }
}

#[doc = " The maximum size of a chunk in the ListExtendedAttributes iterator.\n"]
pub const MAX_LIST_ATTRIBUTES_CHUNK: u64 = 128;

#[derive(Clone, Debug)]
pub struct ExtendedAttributeIteratorGetNextResponse {
    pub attributes: Vec<Vec<u8>>,

    pub last: bool,
}

impl ::fidl_next::Encodable for ExtendedAttributeIteratorGetNextResponse {
    type Encoded = WireExtendedAttributeIteratorGetNextResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExtendedAttributeIteratorGetNextResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                attributes,
                last,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.attributes, encoder, attributes)?;

        ::fidl_next::Encode::encode(&mut self.last, encoder, last)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ExtendedAttributeIteratorGetNextResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireExtendedAttributeIteratorGetNextResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ExtendedAttributeIteratorGetNextResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireExtendedAttributeIteratorGetNextResponse>
    for ExtendedAttributeIteratorGetNextResponse
{
    #[inline]
    fn take_from(from: &WireExtendedAttributeIteratorGetNextResponse) -> Self {
        Self {
            attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),

            last: ::fidl_next::TakeFrom::take_from(&from.last),
        }
    }
}

/// The wire type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireExtendedAttributeIteratorGetNextResponse {
    pub attributes: ::fidl_next::WireVector<::fidl_next::WireVector<u8>>,

    pub last: bool,
}

unsafe impl ::fidl_next::ZeroPadding for WireExtendedAttributeIteratorGetNextResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(17).write_bytes(0, 7);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireExtendedAttributeIteratorGetNextResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut attributes,
                mut last,

            } = slot;
        }

        ::fidl_next::Decode::decode(attributes.as_mut(), decoder)?;

        let attributes = unsafe { attributes.deref_unchecked() };

        if attributes.len() > 128 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: attributes.len() as u64,
                limit: 128,
            });
        }

        ::fidl_next::Decode::decode(last.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the ExtendedAttributeIterator protocol.
#[derive(Debug)]
pub struct ExtendedAttributeIterator;

pub mod extended_attribute_iterator {
    pub mod prelude {
        pub use crate::{
            extended_attribute_iterator, ExtendedAttributeIterator,
            ExtendedAttributeIteratorClientHandler, ExtendedAttributeIteratorClientSender,
            ExtendedAttributeIteratorServerHandler, ExtendedAttributeIteratorServerSender,
        };

        pub use crate::ExtendedAttributeIteratorGetNextResponse;
    }

    pub struct GetNext;

    impl ::fidl_next::Method for GetNext {
        const ORDINAL: u64 = 268639596268373415;

        type Protocol = crate::ExtendedAttributeIterator;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            crate::WireExtendedAttributeIteratorGetNextResponse,
            ::fidl_next::WireI32,
        >;
    }
}

/// A helper trait for the `ExtendedAttributeIterator` client sender.
pub trait ExtendedAttributeIteratorClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, extended_attribute_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> ExtendedAttributeIteratorClientSender
    for ::fidl_next::ClientSender<___T, ExtendedAttributeIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, extended_attribute_iterator::GetNext>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(268639596268373415, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the ExtendedAttributeIterator protocol.
///
/// See [`ExtendedAttributeIterator`] for more details.
pub trait ExtendedAttributeIteratorClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for ExtendedAttributeIterator
where
    ___T: ::fidl_next::Transport,
    ___H: ExtendedAttributeIteratorClientHandler<___T>,

    <extended_attribute_iterator::GetNext as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `ExtendedAttributeIterator` server sender.
pub trait ExtendedAttributeIteratorServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> ExtendedAttributeIteratorServerSender
    for ::fidl_next::ServerSender<___T, ExtendedAttributeIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the ExtendedAttributeIterator protocol.
///
/// See [`ExtendedAttributeIterator`] for more details.
pub trait ExtendedAttributeIteratorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
    fn get_next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, ExtendedAttributeIterator>,

        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for ExtendedAttributeIterator
where
    ___T: ::fidl_next::Transport,
    ___H: ExtendedAttributeIteratorServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            268639596268373415 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_next(sender, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

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

#[doc = " Specifies that this object is not linkable. This is only intended to be used in the context of\n creating a temporary unnamed objects. When that is not the case, the node protocol defines if it\n is linkable (i.e. if it composes the `Linkable` protocol). When this flag is set along with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`, an unnamed temporary object will be created that\n cannot be linked into the filesystem. This would be similar to Linux `O_TMPFILE | O_EXCL`.\n\n CAUTION: if `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY` is not specified,  then this is treated as\n a \"must create\" flag.\n\n The reason for overloading `Flags.FLAG_MUST_CREATE` to mean \"not linkable\" in this context and\n \"must create\" in other contexts is due to the assumption that some POSIX flags are compatible\n with the members in `Flags`. In particular the POSIX `O_EXCL` has the same value as\n `Flags.FLAG_MUST_CREATE`. We are not able to define different bit members of the same value,\n hence it is defined separately outside of `Flags`.\n"]
pub const FLAG_TEMPORARY_AS_NOT_LINKABLE: crate::Flags = crate::Flags::FLAG_MUST_CREATE;

#[derive(Clone, Debug)]
#[repr(C)]
pub struct ReadableReadRequest {
    pub count: u64,
}

impl ::fidl_next::Encodable for ReadableReadRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireReadableReadRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ReadableReadRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                count,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.count, encoder, count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ReadableReadRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireReadableReadRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ReadableReadRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireReadableReadRequest> for ReadableReadRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireReadableReadRequest) -> Self {
        Self { count: ::fidl_next::TakeFrom::take_from(&from.count) }
    }
}

/// The wire type corresponding to [`ReadableReadRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireReadableReadRequest {
    pub count: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireReadableReadRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireReadableReadRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut count,

            } = slot;
        }

        ::fidl_next::Decode::decode(count.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " The maximum I/O size that is allowed for read/write operations using\n byte vectors.\n"]
pub const MAX_TRANSFER_SIZE: u64 = 8192;

#[doc = " The byte vector type used for read/write operations.\n"]
pub type Transfer = Vec<u8>;

/// The wire type corresponding to [`Transfer`].
pub type WireTransfer = ::fidl_next::WireVector<u8>;

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

impl ::fidl_next::Encodable for ReadableReadResponse {
    type Encoded = WireReadableReadResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ReadableReadResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                data,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ReadableReadResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireReadableReadResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ReadableReadResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireReadableReadResponse> for ReadableReadResponse {
    #[inline]
    fn take_from(from: &WireReadableReadResponse) -> Self {
        Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
    }
}

/// The wire type corresponding to [`ReadableReadResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireReadableReadResponse {
    pub data: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireReadableReadResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireReadableReadResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut data,

            } = slot;
        }

        ::fidl_next::Decode::decode(data.as_mut(), decoder)?;

        let data = unsafe { data.deref_unchecked() };

        if data.len() > 8192 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: data.len() as u64,
                limit: 8192,
            });
        }

        Ok(())
    }
}

/// The type corresponding to the Readable protocol.
#[derive(Debug)]
pub struct Readable;

pub mod readable {
    pub mod prelude {
        pub use crate::{
            readable, Readable, ReadableClientHandler, ReadableClientSender, ReadableServerHandler,
            ReadableServerSender,
        };

        pub use crate::ReadableReadRequest;

        pub use crate::ReadableReadResponse;
    }

    pub struct Read;

    impl ::fidl_next::Method for Read {
        const ORDINAL: u64 = 395825947633028830;

        type Protocol = crate::Readable;

        type Request = crate::WireReadableReadRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireReadableReadResponse, ::fidl_next::WireI32>;
    }
}

/// A helper trait for the `Readable` client sender.
pub trait ReadableClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, readable::Read>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireReadableReadRequest,
        >;
}

impl<___T> ReadableClientSender for ::fidl_next::ClientSender<___T, Readable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, readable::Read>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireReadableReadRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(395825947633028830, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Readable protocol.
///
/// See [`Readable`] for more details.
pub trait ReadableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Readable
where
    ___T: ::fidl_next::Transport,
    ___H: ReadableClientHandler<___T>,

    <readable::Read as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Readable` server sender.
pub trait ReadableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> ReadableServerSender for ::fidl_next::ServerSender<___T, Readable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Readable protocol.
///
/// See [`Readable`] for more details.
pub trait ReadableServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Readable>,

        request: ::fidl_next::RequestBuffer<___T, readable::Read>,

        responder: ::fidl_next::Responder<readable::Read>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Readable
where
    ___T: ::fidl_next::Transport,
    ___H: ReadableServerHandler<___T>,

    crate::WireReadableReadRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            395825947633028830 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.read(sender, buffer, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

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

impl ::fidl_next::Encodable for WritableWriteRequest {
    type Encoded = WireWritableWriteRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for WritableWriteRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                data,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<WritableWriteRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireWritableWriteRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<WritableWriteRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireWritableWriteRequest> for WritableWriteRequest {
    #[inline]
    fn take_from(from: &WireWritableWriteRequest) -> Self {
        Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
    }
}

/// The wire type corresponding to [`WritableWriteRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireWritableWriteRequest {
    pub data: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireWritableWriteRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWritableWriteRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut data,

            } = slot;
        }

        ::fidl_next::Decode::decode(data.as_mut(), decoder)?;

        let data = unsafe { data.deref_unchecked() };

        if data.len() > 8192 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: data.len() as u64,
                limit: 8192,
            });
        }

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct WritableWriteResponse {
    pub actual_count: u64,
}

impl ::fidl_next::Encodable for WritableWriteResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireWritableWriteResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for WritableWriteResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                actual_count,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<WritableWriteResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireWritableWriteResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<WritableWriteResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireWritableWriteResponse> for WritableWriteResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireWritableWriteResponse) -> Self {
        Self { actual_count: ::fidl_next::TakeFrom::take_from(&from.actual_count) }
    }
}

/// The wire type corresponding to [`WritableWriteResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireWritableWriteResponse {
    pub actual_count: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireWritableWriteResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWritableWriteResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut actual_count,

            } = slot;
        }

        ::fidl_next::Decode::decode(actual_count.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Writable protocol.
#[derive(Debug)]
pub struct Writable;

pub mod writable {
    pub mod prelude {
        pub use crate::{
            writable, Writable, WritableClientHandler, WritableClientSender, WritableServerHandler,
            WritableServerSender,
        };

        pub use crate::WritableWriteRequest;

        pub use crate::WritableWriteResponse;
    }

    pub struct Write;

    impl ::fidl_next::Method for Write {
        const ORDINAL: u64 = 7651971425397809026;

        type Protocol = crate::Writable;

        type Request = crate::WireWritableWriteRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireWritableWriteResponse, ::fidl_next::WireI32>;
    }
}

/// A helper trait for the `Writable` client sender.
pub trait WritableClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, writable::Write>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireWritableWriteRequest,
        >;
}

impl<___T> WritableClientSender for ::fidl_next::ClientSender<___T, Writable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, writable::Write>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireWritableWriteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7651971425397809026, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Writable protocol.
///
/// See [`Writable`] for more details.
pub trait WritableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Writable
where
    ___T: ::fidl_next::Transport,
    ___H: WritableClientHandler<___T>,

    <writable::Write as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Writable` server sender.
pub trait WritableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> WritableServerSender for ::fidl_next::ServerSender<___T, Writable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Writable protocol.
///
/// See [`Writable`] for more details.
pub trait WritableServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Writable>,

        request: ::fidl_next::RequestBuffer<___T, writable::Write>,

        responder: ::fidl_next::Responder<writable::Write>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Writable
where
    ___T: ::fidl_next::Transport,
    ___H: WritableServerHandler<___T>,

    crate::WireWritableWriteRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            7651971425397809026 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.write(sender, buffer, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

#[derive(Clone, Debug)]
pub struct FileSeekRequest {
    pub origin: crate::SeekOrigin,

    pub offset: i64,
}

impl ::fidl_next::Encodable for FileSeekRequest {
    type Encoded = WireFileSeekRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileSeekRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                origin,
                offset,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.origin, encoder, origin)?;

        ::fidl_next::Encode::encode(&mut self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileSeekRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileSeekRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileSeekRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileSeekRequest> for FileSeekRequest {
    #[inline]
    fn take_from(from: &WireFileSeekRequest) -> Self {
        Self {
            origin: ::fidl_next::TakeFrom::take_from(&from.origin),

            offset: ::fidl_next::TakeFrom::take_from(&from.offset),
        }
    }
}

/// The wire type corresponding to [`FileSeekRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileSeekRequest {
    pub origin: crate::WireSeekOrigin,

    pub offset: ::fidl_next::WireI64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileSeekRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileSeekRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut origin,
                mut offset,

            } = slot;
        }

        ::fidl_next::Decode::decode(origin.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(offset.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FileSeekResponse {
    pub offset_from_start: u64,
}

impl ::fidl_next::Encodable for FileSeekResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFileSeekResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileSeekResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                offset_from_start,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.offset_from_start, encoder, offset_from_start)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileSeekResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireFileSeekResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileSeekResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileSeekResponse> for FileSeekResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileSeekResponse) -> Self {
        Self { offset_from_start: ::fidl_next::TakeFrom::take_from(&from.offset_from_start) }
    }
}

/// The wire type corresponding to [`FileSeekResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileSeekResponse {
    pub offset_from_start: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileSeekResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileSeekResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut offset_from_start,

            } = slot;
        }

        ::fidl_next::Decode::decode(offset_from_start.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FileReadAtRequest {
    pub count: u64,

    pub offset: u64,
}

impl ::fidl_next::Encodable for FileReadAtRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFileReadAtRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileReadAtRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                count,
                offset,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.count, encoder, count)?;

        ::fidl_next::Encode::encode(&mut self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileReadAtRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileReadAtRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileReadAtRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileReadAtRequest> for FileReadAtRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileReadAtRequest) -> Self {
        Self {
            count: ::fidl_next::TakeFrom::take_from(&from.count),

            offset: ::fidl_next::TakeFrom::take_from(&from.offset),
        }
    }
}

/// The wire type corresponding to [`FileReadAtRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileReadAtRequest {
    pub count: ::fidl_next::WireU64,

    pub offset: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileReadAtRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileReadAtRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut count,
                mut offset,

            } = slot;
        }

        ::fidl_next::Decode::decode(count.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(offset.as_mut(), decoder)?;

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for FileReadAtResponse {
    type Encoded = WireFileReadAtResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileReadAtResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                data,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileReadAtResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireFileReadAtResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileReadAtResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileReadAtResponse> for FileReadAtResponse {
    #[inline]
    fn take_from(from: &WireFileReadAtResponse) -> Self {
        Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
    }
}

/// The wire type corresponding to [`FileReadAtResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileReadAtResponse {
    pub data: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileReadAtResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileReadAtResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut data,

            } = slot;
        }

        ::fidl_next::Decode::decode(data.as_mut(), decoder)?;

        let data = unsafe { data.deref_unchecked() };

        if data.len() > 8192 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: data.len() as u64,
                limit: 8192,
            });
        }

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct FileWriteAtRequest {
    pub data: Vec<u8>,

    pub offset: u64,
}

impl ::fidl_next::Encodable for FileWriteAtRequest {
    type Encoded = WireFileWriteAtRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileWriteAtRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                data,
                offset,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.data, encoder, data)?;

        ::fidl_next::Encode::encode(&mut self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileWriteAtRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileWriteAtRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileWriteAtRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileWriteAtRequest> for FileWriteAtRequest {
    #[inline]
    fn take_from(from: &WireFileWriteAtRequest) -> Self {
        Self {
            data: ::fidl_next::TakeFrom::take_from(&from.data),

            offset: ::fidl_next::TakeFrom::take_from(&from.offset),
        }
    }
}

/// The wire type corresponding to [`FileWriteAtRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileWriteAtRequest {
    pub data: ::fidl_next::WireVector<u8>,

    pub offset: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileWriteAtRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileWriteAtRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut data,
                mut offset,

            } = slot;
        }

        ::fidl_next::Decode::decode(data.as_mut(), decoder)?;

        let data = unsafe { data.deref_unchecked() };

        if data.len() > 8192 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: data.len() as u64,
                limit: 8192,
            });
        }

        ::fidl_next::Decode::decode(offset.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FileWriteAtResponse {
    pub actual_count: u64,
}

impl ::fidl_next::Encodable for FileWriteAtResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFileWriteAtResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileWriteAtResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                actual_count,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileWriteAtResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireFileWriteAtResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileWriteAtResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileWriteAtResponse> for FileWriteAtResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileWriteAtResponse) -> Self {
        Self { actual_count: ::fidl_next::TakeFrom::take_from(&from.actual_count) }
    }
}

/// The wire type corresponding to [`FileWriteAtResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileWriteAtResponse {
    pub actual_count: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileWriteAtResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileWriteAtResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut actual_count,

            } = slot;
        }

        ::fidl_next::Decode::decode(actual_count.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FileResizeRequest {
    pub length: u64,
}

impl ::fidl_next::Encodable for FileResizeRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFileResizeRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileResizeRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                length,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.length, encoder, length)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileResizeRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileResizeRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileResizeRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileResizeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileResizeRequest> for FileResizeRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileResizeRequest) -> Self {
        Self { length: ::fidl_next::TakeFrom::take_from(&from.length) }
    }
}

/// The wire type corresponding to [`FileResizeRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileResizeRequest {
    pub length: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileResizeRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileResizeRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut length,

            } = slot;
        }

        ::fidl_next::Decode::decode(length.as_mut(), decoder)?;

        Ok(())
    }
}

pub type FileResizeResponse = ();

/// The wire type corresponding to [`FileResizeResponse`].
pub type WireFileResizeResponse = ();

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

    }
}

impl ::fidl_next::Encodable for VmoFlags {
    type Encoded = WireVmoFlags;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for VmoFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireVmoFlags { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireVmoFlags> for VmoFlags {
    fn from(wire: WireVmoFlags) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireVmoFlags> for VmoFlags {
    #[inline]
    fn take_from(from: &WireVmoFlags) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`VmoFlags`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireVmoFlags {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireVmoFlags {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireVmoFlags
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !VmoFlags::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: VmoFlags::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<VmoFlags> for WireVmoFlags {
    fn from(natural: VmoFlags) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FileGetBackingMemoryRequest {
    pub flags: crate::VmoFlags,
}

impl ::fidl_next::Encodable for FileGetBackingMemoryRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::VmoFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFileGetBackingMemoryRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileGetBackingMemoryRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                flags,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileGetBackingMemoryRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileGetBackingMemoryRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileGetBackingMemoryRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileGetBackingMemoryRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileGetBackingMemoryRequest> for FileGetBackingMemoryRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::VmoFlags as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileGetBackingMemoryRequest) -> Self {
        Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
    }
}

/// The wire type corresponding to [`FileGetBackingMemoryRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFileGetBackingMemoryRequest {
    pub flags: crate::WireVmoFlags,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileGetBackingMemoryRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileGetBackingMemoryRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut flags,

            } = slot;
        }

        ::fidl_next::Decode::decode(flags.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct FileGetBackingMemoryResponse {
    pub vmo: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for FileGetBackingMemoryResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    type Encoded = WireFileGetBackingMemoryResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileGetBackingMemoryResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                vmo,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.vmo, encoder, vmo)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileGetBackingMemoryResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireFileGetBackingMemoryResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileGetBackingMemoryResponse>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileGetBackingMemoryResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileGetBackingMemoryResponse> for FileGetBackingMemoryResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFileGetBackingMemoryResponse) -> Self {
        Self { vmo: ::fidl_next::TakeFrom::take_from(&from.vmo) }
    }
}

/// The wire type corresponding to [`FileGetBackingMemoryResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileGetBackingMemoryResponse {
    pub vmo: ::fidl_next::fuchsia::WireHandle,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileGetBackingMemoryResponse {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileGetBackingMemoryResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut vmo,

            } = slot;
        }

        ::fidl_next::Decode::decode(vmo.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Debug)]
pub struct LinkableLinkIntoRequest {
    pub dst_parent_token: ::fidl_next::fuchsia::zx::Handle,

    pub dst: String,
}

impl ::fidl_next::Encodable for LinkableLinkIntoRequest {
    type Encoded = WireLinkableLinkIntoRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for LinkableLinkIntoRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                dst_parent_token,
                dst,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.dst_parent_token, encoder, dst_parent_token)?;

        ::fidl_next::Encode::encode(&mut self.dst, encoder, dst)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LinkableLinkIntoRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLinkableLinkIntoRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<LinkableLinkIntoRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LinkableLinkIntoRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLinkableLinkIntoRequest> for LinkableLinkIntoRequest {
    #[inline]
    fn take_from(from: &WireLinkableLinkIntoRequest) -> Self {
        Self {
            dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

            dst: ::fidl_next::TakeFrom::take_from(&from.dst),
        }
    }
}

/// The wire type corresponding to [`LinkableLinkIntoRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLinkableLinkIntoRequest {
    pub dst_parent_token: ::fidl_next::fuchsia::WireHandle,

    pub dst: ::fidl_next::WireString,
}

unsafe impl ::fidl_next::ZeroPadding for WireLinkableLinkIntoRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLinkableLinkIntoRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut dst_parent_token,
                mut dst,

            } = slot;
        }

        ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(dst.as_mut(), decoder)?;

        let dst = unsafe { dst.deref_unchecked() };

        if dst.len() > 255 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: dst.len() as u64,
                limit: 255,
            });
        }

        Ok(())
    }
}

pub type LinkableLinkIntoResponse = ();

/// The wire type corresponding to [`LinkableLinkIntoResponse`].
pub type WireLinkableLinkIntoResponse = ();

/// The type corresponding to the Linkable protocol.
#[derive(Debug)]
pub struct Linkable;

pub mod linkable {
    pub mod prelude {
        pub use crate::{
            linkable, Linkable, LinkableClientHandler, LinkableClientSender, LinkableServerHandler,
            LinkableServerSender,
        };

        pub use crate::LinkableLinkIntoRequest;

        pub use crate::LinkableLinkIntoResponse;
    }

    pub struct LinkInto;

    impl ::fidl_next::Method for LinkInto {
        const ORDINAL: u64 = 6121399674497678964;

        type Protocol = crate::Linkable;

        type Request = crate::WireLinkableLinkIntoRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireLinkableLinkIntoResponse, ::fidl_next::WireI32>;
    }
}

/// A helper trait for the `Linkable` client sender.
pub trait LinkableClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, linkable::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >;
}

impl<___T> LinkableClientSender for ::fidl_next::ClientSender<___T, Linkable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, linkable::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6121399674497678964, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Linkable protocol.
///
/// See [`Linkable`] for more details.
pub trait LinkableClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Linkable
where
    ___T: ::fidl_next::Transport,
    ___H: LinkableClientHandler<___T>,

    <linkable::LinkInto as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Linkable` server sender.
pub trait LinkableServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> LinkableServerSender for ::fidl_next::ServerSender<___T, Linkable>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

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

        request: ::fidl_next::RequestBuffer<___T, linkable::LinkInto>,

        responder: ::fidl_next::Responder<linkable::LinkInto>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Linkable
where
    ___T: ::fidl_next::Transport,
    ___H: LinkableServerHandler<___T>,

    crate::WireLinkableLinkIntoRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            6121399674497678964 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.link_into(sender, buffer, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

#[derive(Debug)]
pub struct FileAllocateRequest {
    pub offset: u64,

    pub length: u64,

    pub mode: crate::AllocateMode,
}

impl ::fidl_next::Encodable for FileAllocateRequest {
    type Encoded = WireFileAllocateRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileAllocateRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                offset,
                length,
                mode,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.offset, encoder, offset)?;

        ::fidl_next::Encode::encode(&mut self.length, encoder, length)?;

        ::fidl_next::Encode::encode(&mut self.mode, encoder, mode)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileAllocateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileAllocateRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileAllocateRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileAllocateRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileAllocateRequest> for FileAllocateRequest {
    #[inline]
    fn take_from(from: &WireFileAllocateRequest) -> Self {
        Self {
            offset: ::fidl_next::TakeFrom::take_from(&from.offset),

            length: ::fidl_next::TakeFrom::take_from(&from.length),

            mode: ::fidl_next::TakeFrom::take_from(&from.mode),
        }
    }
}

/// The wire type corresponding to [`FileAllocateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileAllocateRequest {
    pub offset: ::fidl_next::WireU64,

    pub length: ::fidl_next::WireU64,

    pub mode: crate::WireAllocateMode,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileAllocateRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileAllocateRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut offset,
                mut length,
                mut mode,

            } = slot;
        }

        ::fidl_next::Decode::decode(offset.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(length.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(mode.as_mut(), decoder)?;

        Ok(())
    }
}

pub type FileAllocateResponse = ();

/// The wire type corresponding to [`FileAllocateResponse`].
pub type WireFileAllocateResponse = ();

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

impl ::fidl_next::Encodable for FileEnableVerityRequest {
    type Encoded = WireFileEnableVerityRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileEnableVerityRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                options,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.options, encoder, options)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileEnableVerityRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireFileEnableVerityRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileEnableVerityRequest>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileEnableVerityRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileEnableVerityRequest> for FileEnableVerityRequest {
    #[inline]
    fn take_from(from: &WireFileEnableVerityRequest) -> Self {
        Self { options: ::fidl_next::TakeFrom::take_from(&from.options) }
    }
}

/// The wire type corresponding to [`FileEnableVerityRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileEnableVerityRequest {
    pub options: crate::WireVerificationOptions,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileEnableVerityRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileEnableVerityRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut options,

            } = slot;
        }

        ::fidl_next::Decode::decode(options.as_mut(), decoder)?;

        Ok(())
    }
}

pub type FileEnableVerityResponse = ();

/// The wire type corresponding to [`FileEnableVerityResponse`].
pub type WireFileEnableVerityResponse = ();

/// The type corresponding to the File protocol.
#[doc = " A [`Node`] which contains a sequence of bytes of definite length.\n\n NOTE: cloned connections do not share their seek offset with their source\n connection.\n"]
#[derive(Debug)]
pub struct File;

impl ::fidl_next::Discoverable for File {
    const PROTOCOL_NAME: &'static str = "file";
}

pub mod file {
    pub mod prelude {
        pub use crate::{
            file, File, FileClientHandler, FileClientSender, FileServerHandler, FileServerSender,
        };

        pub use crate::AdvisoryLockingAdvisoryLockRequest;

        pub use crate::AdvisoryLockingAdvisoryLockResponse;

        pub use crate::ConnectionInfo;

        pub use crate::ExtendedAttributeValue;

        pub use crate::FileAllocateRequest;

        pub use crate::FileEnableVerityRequest;

        pub use crate::FileGetBackingMemoryRequest;

        pub use crate::FileInfo;

        pub use crate::FileReadAtRequest;

        pub use crate::FileResizeRequest;

        pub use crate::FileSeekRequest;

        pub use crate::FileWriteAtRequest;

        pub use crate::FileAllocateResponse;

        pub use crate::FileEnableVerityResponse;

        pub use crate::FileGetBackingMemoryResponse;

        pub use crate::FileReadAtResponse;

        pub use crate::FileResizeResponse;

        pub use crate::FileSeekResponse;

        pub use crate::FileWriteAtResponse;

        pub use crate::LinkableLinkIntoRequest;

        pub use crate::LinkableLinkIntoResponse;

        pub use crate::MutableNodeAttributes;

        pub use crate::NodeAttributes2;

        pub use crate::NodeDeprecatedCloneRequest;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        pub use crate::NodeGetAttrResponse;

        pub use crate::NodeGetAttributesRequest;

        pub use crate::NodeGetExtendedAttributeRequest;

        pub use crate::NodeListExtendedAttributesRequest;

        pub use crate::NodeOnOpenRequest;

        pub use crate::NodeQueryFilesystemResponse;

        pub use crate::NodeRemoveExtendedAttributeRequest;

        pub use crate::NodeSetAttrRequest;

        pub use crate::NodeSetAttrResponse;

        pub use crate::NodeSetExtendedAttributeRequest;

        pub use crate::NodeSetFlagsRequest;

        pub use crate::NodeGetFlagsResponse;

        pub use crate::NodeRemoveExtendedAttributeResponse;

        pub use crate::NodeSetExtendedAttributeResponse;

        pub use crate::NodeSetFlagsResponse;

        pub use crate::NodeSyncResponse;

        pub use crate::NodeUpdateAttributesResponse;

        pub use crate::ReadableReadRequest;

        pub use crate::ReadableReadResponse;

        pub use crate::Representation;

        pub use crate::WritableWriteRequest;

        pub use crate::WritableWriteResponse;

        pub use ::fidl_next_fuchsia_unknown::CloneableCloneRequest;

        pub use ::fidl_next_fuchsia_unknown::CloseableCloseResponse;

        pub use ::fidl_next_fuchsia_unknown::QueryableQueryResponse;
    }

    pub struct AdvisoryLock;

    impl ::fidl_next::Method for AdvisoryLock {
        const ORDINAL: u64 = 7992130864415541162;

        type Protocol = crate::File;

        type Request = crate::WireAdvisoryLockingAdvisoryLockRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireAdvisoryLockingAdvisoryLockResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct LinkInto;

    impl ::fidl_next::Method for LinkInto {
        const ORDINAL: u64 = 6121399674497678964;

        type Protocol = crate::File;

        type Request = crate::WireLinkableLinkIntoRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireLinkableLinkIntoResponse, ::fidl_next::WireI32>;
    }

    pub struct Clone;

    impl ::fidl_next::Method for Clone {
        const ORDINAL: u64 = 2366825959783828089;

        type Protocol = crate::File;

        type Request = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct Close;

    impl ::fidl_next::Method for Close {
        const ORDINAL: u64 = 6540867515453498750;

        type Protocol = crate::File;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            ::fidl_next_fuchsia_unknown::WireCloseableCloseResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Query;

    impl ::fidl_next::Method for Query {
        const ORDINAL: u64 = 2763219980499352582;

        type Protocol = crate::File;

        type Request = ();

        type Response = ::fidl_next_fuchsia_unknown::WireQueryableQueryResponse;
    }

    pub struct DeprecatedClone;

    impl ::fidl_next::Method for DeprecatedClone {
        const ORDINAL: u64 = 6512600400724287855;

        type Protocol = crate::File;

        type Request = crate::WireNodeDeprecatedCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct OnOpen;

    impl ::fidl_next::Method for OnOpen {
        const ORDINAL: u64 = 9207534335756671346;

        type Protocol = crate::File;

        type Request = ::fidl_next::Never;

        type Response = crate::WireNodeOnOpenRequest;
    }

    pub struct GetAttr;

    impl ::fidl_next::Method for GetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireNodeGetAttrResponse;
    }

    pub struct SetAttr;

    impl ::fidl_next::Method for SetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::File;

        type Request = crate::WireNodeSetAttrRequest;

        type Response = crate::WireNodeSetAttrResponse;
    }

    pub struct DeprecatedGetFlags;

    impl ::fidl_next::Method for DeprecatedGetFlags {
        const ORDINAL: u64 = 6595803110182632097;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetFlagsResponse;
    }

    pub struct DeprecatedSetFlags;

    impl ::fidl_next::Method for DeprecatedSetFlags {
        const ORDINAL: u64 = 5950864159036794675;

        type Protocol = crate::File;

        type Request = crate::WireNodeDeprecatedSetFlagsRequest;

        type Response = crate::WireNodeDeprecatedSetFlagsResponse;
    }

    pub struct GetFlags;

    impl ::fidl_next::Method for GetFlags {
        const ORDINAL: u64 = 105530239381466147;

        type Protocol = crate::File;

        type Request = ();

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeGetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct SetFlags;

    impl ::fidl_next::Method for SetFlags {
        const ORDINAL: u64 = 6172186066099445416;

        type Protocol = crate::File;

        type Request = crate::WireNodeSetFlagsRequest;

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeSetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct QueryFilesystem;

    impl ::fidl_next::Method for QueryFilesystem {
        const ORDINAL: u64 = 8013111122914313744;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireNodeQueryFilesystemResponse;
    }

    pub struct OnRepresentation;

    impl ::fidl_next::Method for OnRepresentation {
        const ORDINAL: u64 = 6679970090861613324;

        type Protocol = crate::File;

        type Request = ::fidl_next::Never;

        type Response = crate::WireRepresentation;
    }

    pub struct GetConnectionInfo;

    impl ::fidl_next::Method for GetConnectionInfo {
        const ORDINAL: u64 = 6362521381364198667;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireConnectionInfo;
    }

    pub struct GetAttributes;

    impl ::fidl_next::Method for GetAttributes {
        const ORDINAL: u64 = 4414537700416816443;

        type Protocol = crate::File;

        type Request = crate::WireNodeGetAttributesRequest;

        type Response = ::fidl_next::WireResult<crate::WireNodeAttributes2, ::fidl_next::WireI32>;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::File;

        type Request = crate::WireMutableNodeAttributes;

        type Response =
            ::fidl_next::WireResult<crate::WireNodeUpdateAttributesResponse, ::fidl_next::WireI32>;
    }

    pub struct Sync;

    impl ::fidl_next::Method for Sync {
        const ORDINAL: u64 = 3196473584242777161;

        type Protocol = crate::File;

        type Request = ();

        type Response = ::fidl_next::WireResult<crate::WireNodeSyncResponse, ::fidl_next::WireI32>;
    }

    pub struct ListExtendedAttributes;

    impl ::fidl_next::Method for ListExtendedAttributes {
        const ORDINAL: u64 = 5431626189872037072;

        type Protocol = crate::File;

        type Request = crate::WireNodeListExtendedAttributesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct GetExtendedAttribute;

    impl ::fidl_next::Method for GetExtendedAttribute {
        const ORDINAL: u64 = 5043930208506967771;

        type Protocol = crate::File;

        type Request = crate::WireNodeGetExtendedAttributeRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireExtendedAttributeValue, ::fidl_next::WireI32>;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::File;

        type Request = crate::WireNodeSetExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeSetExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct RemoveExtendedAttribute;

    impl ::fidl_next::Method for RemoveExtendedAttribute {
        const ORDINAL: u64 = 8794297771444732717;

        type Protocol = crate::File;

        type Request = crate::WireNodeRemoveExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeRemoveExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Read;

    impl ::fidl_next::Method for Read {
        const ORDINAL: u64 = 395825947633028830;

        type Protocol = crate::File;

        type Request = crate::WireReadableReadRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireReadableReadResponse, ::fidl_next::WireI32>;
    }

    pub struct Write;

    impl ::fidl_next::Method for Write {
        const ORDINAL: u64 = 7651971425397809026;

        type Protocol = crate::File;

        type Request = crate::WireWritableWriteRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireWritableWriteResponse, ::fidl_next::WireI32>;
    }

    pub struct Describe;

    impl ::fidl_next::Method for Describe {
        const ORDINAL: u64 = 7545125870053689020;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireFileInfo;
    }

    pub struct Seek;

    impl ::fidl_next::Method for Seek {
        const ORDINAL: u64 = 8649041485622956551;

        type Protocol = crate::File;

        type Request = crate::WireFileSeekRequest;

        type Response = ::fidl_next::WireResult<crate::WireFileSeekResponse, ::fidl_next::WireI32>;
    }

    pub struct ReadAt;

    impl ::fidl_next::Method for ReadAt {
        const ORDINAL: u64 = 1587416148701180478;

        type Protocol = crate::File;

        type Request = crate::WireFileReadAtRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireFileReadAtResponse, ::fidl_next::WireI32>;
    }

    pub struct WriteAt;

    impl ::fidl_next::Method for WriteAt {
        const ORDINAL: u64 = 8736683935131400491;

        type Protocol = crate::File;

        type Request = crate::WireFileWriteAtRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireFileWriteAtResponse, ::fidl_next::WireI32>;
    }

    pub struct Resize;

    impl ::fidl_next::Method for Resize {
        const ORDINAL: u64 = 3134648685270758458;

        type Protocol = crate::File;

        type Request = crate::WireFileResizeRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireFileResizeResponse, ::fidl_next::WireI32>;
    }

    pub struct GetBackingMemory;

    impl ::fidl_next::Method for GetBackingMemory {
        const ORDINAL: u64 = 46911652864194091;

        type Protocol = crate::File;

        type Request = crate::WireFileGetBackingMemoryRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireFileGetBackingMemoryResponse, ::fidl_next::WireI32>;
    }

    pub struct Allocate;

    impl ::fidl_next::Method for Allocate {
        const ORDINAL: u64 = 8645235848064269614;

        type Protocol = crate::File;

        type Request = crate::WireFileAllocateRequest;

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireFileAllocateResponse, ::fidl_next::WireI32>;
    }

    pub struct EnableVerity;

    impl ::fidl_next::Method for EnableVerity {
        const ORDINAL: u64 = 3189145313204943035;

        type Protocol = crate::File;

        type Request = crate::WireFileEnableVerityRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireFileEnableVerityResponse,
            ::fidl_next::WireI32,
        >;
    }
}

/// A helper trait for the `File` client sender.
pub trait FileClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >;

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >;

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Close>,
        ::fidl_next::EncodeError,
    >;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Query>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >;

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetAttr>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >;

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::QueryFilesystem>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >;

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >;

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Sync>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >;

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >;

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >;

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >;

    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Read>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireReadableReadRequest,
        >;

    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Write>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireWritableWriteRequest,
        >;

    fn describe(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Describe>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n   of the file.\n\n This method does not require any rights.\n"]
    fn seek<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Seek>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileSeekRequest,
        >;

    #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that `ReadAt` has hit\n   the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n   is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually reading anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read_at<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::ReadAt>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileReadAtRequest,
        >;

    #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file, and will return a\n   successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write_at<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::WriteAt>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileWriteAtRequest,
        >;

    #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn resize<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Resize>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileResizeRequest,
        >;

    #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
    fn get_backing_memory<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetBackingMemory>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileGetBackingMemoryRequest,
        >;

    #[doc = " Pre-allocate on-disk space for this file.\n"]
    fn allocate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Allocate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileAllocateRequest,
        >;

    #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
    fn enable_verity<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::EnableVerity>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileEnableVerityRequest,
        >;
}

impl<___T> FileClientSender for ::fidl_next::ClientSender<___T, File>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::AdvisoryLock>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7992130864415541162, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6121399674497678964, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(2366825959783828089, request)
    }

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Close>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6540867515453498750, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Query>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2763219980499352582, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(6512600400724287855, request)
    }

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetAttr>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8689798978500614909, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4721673413776871238, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6595803110182632097, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5950864159036794675, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(105530239381466147, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6172186066099445416, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::QueryFilesystem>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8013111122914313744, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6362521381364198667, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4414537700416816443, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >,
    {
        self.as_untyped()
            .send_two_way(3677402239314018056, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Sync>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(3196473584242777161, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >,
    {
        self.as_untyped().send_one_way(5431626189872037072, request)
    }

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5043930208506967771, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5374223046099989052, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8794297771444732717, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Read>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireReadableReadRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(395825947633028830, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Write>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireWritableWriteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7651971425397809026, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn describe(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Describe>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(7545125870053689020, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n   of the file.\n\n This method does not require any rights.\n"]
    fn seek<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Seek>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileSeekRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8649041485622956551, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that `ReadAt` has hit\n   the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n   is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually reading anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read_at<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::ReadAt>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileReadAtRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(1587416148701180478, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file, and will return a\n   successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write_at<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::WriteAt>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileWriteAtRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8736683935131400491, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn resize<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Resize>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileResizeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(3134648685270758458, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
    fn get_backing_memory<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::GetBackingMemory>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileGetBackingMemoryRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(46911652864194091, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Pre-allocate on-disk space for this file.\n"]
    fn allocate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::Allocate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileAllocateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8645235848064269614, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
    fn enable_verity<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, file::EnableVerity>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireFileEnableVerityRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(3189145313204943035, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the File protocol.
///
/// See [`File`] for more details.
pub trait FileClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
    fn on_open(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, File>,

        message: ::fidl_next::ResponseBuffer<___T, file::OnOpen>,
    );

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
    fn on_representation(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, File>,

        message: ::fidl_next::ResponseBuffer<___T, file::OnRepresentation>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, File>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for File
where
    ___T: ::fidl_next::Transport,
    ___H: FileClientHandler<___T>,

    <file::AdvisoryLock as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::LinkInto as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Close as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Query as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::OnOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::SetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedGetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedSetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::SetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::QueryFilesystem as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::OnRepresentation as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetConnectionInfo as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::UpdateAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Sync as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::SetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::RemoveExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Read as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Write as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Describe as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Seek as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::ReadAt as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::WriteAt as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Resize as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetBackingMemory as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Allocate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::EnableVerity as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_open(sender, buffer);
            }

            6679970090861613324 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_representation(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `File` server sender.
pub trait FileServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <file::OnOpen as ::fidl_next::Method>::Response,
        >;

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <file::OnRepresentation as ::fidl_next::Method>::Response,
        >;
}

impl<___T> FileServerSender for ::fidl_next::ServerSender<___T, File>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <file::OnOpen as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(9207534335756671346, request)
    }

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <file::OnRepresentation as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(6679970090861613324, request)
    }
}

/// A server handler for the File protocol.
///
/// See [`File`] for more details.
pub trait FileServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
    fn advisory_lock(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::AdvisoryLock>,

        responder: ::fidl_next::Responder<file::AdvisoryLock>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, file::LinkInto>,

        responder: ::fidl_next::Responder<file::LinkInto>,
    );

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::Clone>,
    );

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::Close>,
    );

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::Query>,
    );

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::DeprecatedClone>,
    );

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::GetAttr>,
    );

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::SetAttr>,

        responder: ::fidl_next::Responder<file::SetAttr>,
    );

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::DeprecatedGetFlags>,
    );

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::DeprecatedSetFlags>,

        responder: ::fidl_next::Responder<file::DeprecatedSetFlags>,
    );

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::GetFlags>,
    );

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::SetFlags>,

        responder: ::fidl_next::Responder<file::SetFlags>,
    );

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::QueryFilesystem>,
    );

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::GetConnectionInfo>,
    );

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::GetAttributes>,

        responder: ::fidl_next::Responder<file::GetAttributes>,
    );

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::UpdateAttributes>,

        responder: ::fidl_next::Responder<file::UpdateAttributes>,
    );

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::Sync>,
    );

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::ListExtendedAttributes>,
    );

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::GetExtendedAttribute>,

        responder: ::fidl_next::Responder<file::GetExtendedAttribute>,
    );

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::SetExtendedAttribute>,

        responder: ::fidl_next::Responder<file::SetExtendedAttribute>,
    );

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::RemoveExtendedAttribute>,

        responder: ::fidl_next::Responder<file::RemoveExtendedAttribute>,
    );

    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::Read>,

        responder: ::fidl_next::Responder<file::Read>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, file::Write>,

        responder: ::fidl_next::Responder<file::Write>,
    );

    fn describe(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        responder: ::fidl_next::Responder<file::Describe>,
    );

    #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n   of the file.\n\n This method does not require any rights.\n"]
    fn seek(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::Seek>,

        responder: ::fidl_next::Responder<file::Seek>,
    );

    #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that `ReadAt` has hit\n   the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n   is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually reading anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
    fn read_at(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::ReadAt>,

        responder: ::fidl_next::Responder<file::ReadAt>,
    );

    #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file, and will return a\n   successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn write_at(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::WriteAt>,

        responder: ::fidl_next::Responder<file::WriteAt>,
    );

    #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
    fn resize(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::Resize>,

        responder: ::fidl_next::Responder<file::Resize>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, file::GetBackingMemory>,

        responder: ::fidl_next::Responder<file::GetBackingMemory>,
    );

    #[doc = " Pre-allocate on-disk space for this file.\n"]
    fn allocate(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,

        request: ::fidl_next::RequestBuffer<___T, file::Allocate>,

        responder: ::fidl_next::Responder<file::Allocate>,
    );

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

        request: ::fidl_next::RequestBuffer<___T, file::EnableVerity>,

        responder: ::fidl_next::Responder<file::EnableVerity>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, File>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for File
where
    ___T: ::fidl_next::Transport,
    ___H: FileServerHandler<___T>,

    crate::WireAdvisoryLockingAdvisoryLockRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireLinkableLinkIntoRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetAttrRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireMutableNodeAttributes:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeListExtendedAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeRemoveExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireReadableReadRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireWritableWriteRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileSeekRequest: ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileReadAtRequest: ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileWriteAtRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileResizeRequest: ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileGetBackingMemoryRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileAllocateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireFileEnableVerityRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.clone(sender, buffer);
            }

            6512600400724287855 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_clone(sender, buffer);
            }

            5431626189872037072 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.list_extended_attributes(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            7992130864415541162 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.advisory_lock(sender, buffer, responder);
            }

            6121399674497678964 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.link_into(sender, buffer, responder);
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder);
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder);
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_attr(sender, responder);
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_attr(sender, buffer, responder);
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder);
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_set_flags(sender, buffer, responder);
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder);
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_flags(sender, buffer, responder);
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder);
            }

            6362521381364198667 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_connection_info(sender, responder);
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_attributes(sender, buffer, responder);
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.update_attributes(sender, buffer, responder);
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder);
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_extended_attribute(sender, buffer, responder);
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_extended_attribute(sender, buffer, responder);
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.remove_extended_attribute(sender, buffer, responder);
            }

            395825947633028830 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.read(sender, buffer, responder);
            }

            7651971425397809026 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.write(sender, buffer, responder);
            }

            7545125870053689020 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.describe(sender, responder);
            }

            8649041485622956551 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.seek(sender, buffer, responder);
            }

            1587416148701180478 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.read_at(sender, buffer, responder);
            }

            8736683935131400491 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.write_at(sender, buffer, responder);
            }

            3134648685270758458 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.resize(sender, buffer, responder);
            }

            46911652864194091 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_backing_memory(sender, buffer, responder);
            }

            8645235848064269614 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.allocate(sender, buffer, responder);
            }

            3189145313204943035 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.enable_verity(sender, buffer, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct FileObject {
    pub event: Option<::fidl_next::fuchsia::zx::Handle>,

    pub stream: Option<::fidl_next::fuchsia::zx::Handle>,
}

impl ::fidl_next::Encodable for FileObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireFileObject;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileObject
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                event,
                stream,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.event, encoder, event)?;

        ::fidl_next::Encode::encode(&mut self.stream, encoder, stream)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FileObject> {
    type EncodedOption = ::fidl_next::WireBox<WireFileObject>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FileObject>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFileObject> for FileObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireFileObject) -> Self {
        Self {
            event: ::fidl_next::TakeFrom::take_from(&from.event),

            stream: ::fidl_next::TakeFrom::take_from(&from.stream),
        }
    }
}

/// The wire type corresponding to [`FileObject`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileObject {
    pub event: ::fidl_next::fuchsia::WireOptionalHandle,

    pub stream: ::fidl_next::fuchsia::WireOptionalHandle,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileObject {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileObject
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut event,
                mut stream,

            } = slot;
        }

        ::fidl_next::Decode::decode(event.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(stream.as_mut(), decoder)?;

        Ok(())
    }
}

::fidl_next::bitflags! {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
    )]
    pub struct FileSignal: u32 {
        #[doc = " Indicates the file is ready for reading.\n"]const READABLE = 16777216;
        #[doc = " Indicates the file is ready for writing.\n"]const WRITABLE = 33554432;

    }
}

impl ::fidl_next::Encodable for FileSignal {
    type Encoded = WireFileSignal;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FileSignal
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireFileSignal { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireFileSignal> for FileSignal {
    fn from(wire: WireFileSignal) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::TakeFrom<WireFileSignal> for FileSignal {
    #[inline]
    fn take_from(from: &WireFileSignal) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`FileSignal`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireFileSignal {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::ZeroPadding for WireFileSignal {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileSignal
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);
        let set = u32::from(*value);
        if set & !FileSignal::all().bits() != 0 {
            return Err(::fidl_next::DecodeError::InvalidBits {
                expected: FileSignal::all().bits() as usize,
                actual: set as usize,
            });
        }

        Ok(())
    }
}

impl ::core::convert::From<FileSignal> for WireFileSignal {
    fn from(natural: FileSignal) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

pub const MAX_FS_NAME_BUFFER: u64 = 32;

#[derive(Clone, Debug)]
#[repr(C)]
pub struct FilesystemInfo {
    pub total_bytes: u64,

    pub used_bytes: u64,

    pub total_nodes: u64,

    pub used_nodes: u64,

    pub free_shared_pool_bytes: u64,

    pub fs_id: u64,

    pub block_size: u32,

    pub max_filename_size: u32,

    pub fs_type: u32,

    pub padding: u32,

    pub name: [i8; 32],
}

impl ::fidl_next::Encodable for FilesystemInfo {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <[i8; 32] as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireFilesystemInfo;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FilesystemInfo
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                total_bytes,
                used_bytes,
                total_nodes,
                used_nodes,
                free_shared_pool_bytes,
                fs_id,
                block_size,
                max_filename_size,
                fs_type,
                padding,
                name,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.total_bytes, encoder, total_bytes)?;

        ::fidl_next::Encode::encode(&mut self.used_bytes, encoder, used_bytes)?;

        ::fidl_next::Encode::encode(&mut self.total_nodes, encoder, total_nodes)?;

        ::fidl_next::Encode::encode(&mut self.used_nodes, encoder, used_nodes)?;

        ::fidl_next::Encode::encode(
            &mut self.free_shared_pool_bytes,
            encoder,
            free_shared_pool_bytes,
        )?;

        ::fidl_next::Encode::encode(&mut self.fs_id, encoder, fs_id)?;

        ::fidl_next::Encode::encode(&mut self.block_size, encoder, block_size)?;

        ::fidl_next::Encode::encode(&mut self.max_filename_size, encoder, max_filename_size)?;

        ::fidl_next::Encode::encode(&mut self.fs_type, encoder, fs_type)?;

        ::fidl_next::Encode::encode(&mut self.padding, encoder, padding)?;

        ::fidl_next::Encode::encode(&mut self.name, encoder, name)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FilesystemInfo> {
    type EncodedOption = ::fidl_next::WireBox<WireFilesystemInfo>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<FilesystemInfo>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FilesystemInfo: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireFilesystemInfo> for FilesystemInfo {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <u32 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <[i8; 32] as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireFilesystemInfo) -> Self {
        Self {
            total_bytes: ::fidl_next::TakeFrom::take_from(&from.total_bytes),

            used_bytes: ::fidl_next::TakeFrom::take_from(&from.used_bytes),

            total_nodes: ::fidl_next::TakeFrom::take_from(&from.total_nodes),

            used_nodes: ::fidl_next::TakeFrom::take_from(&from.used_nodes),

            free_shared_pool_bytes: ::fidl_next::TakeFrom::take_from(&from.free_shared_pool_bytes),

            fs_id: ::fidl_next::TakeFrom::take_from(&from.fs_id),

            block_size: ::fidl_next::TakeFrom::take_from(&from.block_size),

            max_filename_size: ::fidl_next::TakeFrom::take_from(&from.max_filename_size),

            fs_type: ::fidl_next::TakeFrom::take_from(&from.fs_type),

            padding: ::fidl_next::TakeFrom::take_from(&from.padding),

            name: ::fidl_next::TakeFrom::take_from(&from.name),
        }
    }
}

/// The wire type corresponding to [`FilesystemInfo`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireFilesystemInfo {
    pub total_bytes: ::fidl_next::WireU64,

    pub used_bytes: ::fidl_next::WireU64,

    pub total_nodes: ::fidl_next::WireU64,

    pub used_nodes: ::fidl_next::WireU64,

    pub free_shared_pool_bytes: ::fidl_next::WireU64,

    pub fs_id: ::fidl_next::WireU64,

    pub block_size: ::fidl_next::WireU32,

    pub max_filename_size: ::fidl_next::WireU32,

    pub fs_type: ::fidl_next::WireU32,

    pub padding: ::fidl_next::WireU32,

    pub name: [i8; 32],
}

unsafe impl ::fidl_next::ZeroPadding for WireFilesystemInfo {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFilesystemInfo
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut total_bytes,
                mut used_bytes,
                mut total_nodes,
                mut used_nodes,
                mut free_shared_pool_bytes,
                mut fs_id,
                mut block_size,
                mut max_filename_size,
                mut fs_type,
                mut padding,
                mut name,

            } = slot;
        }

        ::fidl_next::Decode::decode(total_bytes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(used_bytes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(total_nodes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(used_nodes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(free_shared_pool_bytes.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(fs_id.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(block_size.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(max_filename_size.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(fs_type.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(padding.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(name.as_mut(), decoder)?;

        Ok(())
    }
}

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

#[doc = " Nodes which do not have ino values should return this value\n from Readdir and GetAttr.\n"]
pub const INO_UNKNOWN: u64 = 18446744073709551615;

pub const MASK_KNOWN_PERMISSIONS: crate::Flags = crate::Flags::from_bits_retain(25087);

pub const MASK_KNOWN_PROTOCOLS: crate::Flags = crate::Flags::from_bits_retain(30069489664);

pub const MASK_PERMISSION_FLAGS: u64 = 65535;

pub const MASK_POSIX_FLAGS: u64 = 4294967295;

#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
pub const MAX_FILENAME: u64 = 255;

#[doc = " Bits reserved for posix protections. Native fuchsia filesystems\n are not required to set bits contained within `MODE_PROTECTION_MASK`,\n but filesystems that wish to do so may refer to sys/stat.h for their\n definitions.\n"]
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;

#[doc = " Bits indicating node type. The canonical mechanism to check\n for a node type is to take \'mode\', bitwise AND it with the\n `MODE_TYPE_MASK`, and check exact equality against a mode type.\n"]
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";

#[derive(Clone, Debug)]
#[repr(C)]
pub struct Service {}

impl ::fidl_next::Encodable for Service {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    type Encoded = WireService;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Service
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Service> {
    type EncodedOption = ::fidl_next::WireBox<WireService>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<Service>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    Service: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireService> for Service {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn take_from(from: &WireService) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`Service`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireService {}

unsafe impl ::fidl_next::ZeroPadding for WireService {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireService
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

            } = slot;
        }

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for SymlinkObject {
    type Encoded = WireSymlinkObject;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SymlinkObject
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                target,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.target, encoder, target)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<SymlinkObject> {
    type EncodedOption = ::fidl_next::WireBox<WireSymlinkObject>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<SymlinkObject>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SymlinkObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireSymlinkObject> for SymlinkObject {
    #[inline]
    fn take_from(from: &WireSymlinkObject) -> Self {
        Self { target: ::fidl_next::TakeFrom::take_from(&from.target) }
    }
}

/// The wire type corresponding to [`SymlinkObject`].
#[derive(Debug)]
#[repr(C)]
pub struct WireSymlinkObject {
    pub target: ::fidl_next::WireVector<u8>,
}

unsafe impl ::fidl_next::ZeroPadding for WireSymlinkObject {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSymlinkObject
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut target,

            } = slot;
        }

        ::fidl_next::Decode::decode(target.as_mut(), decoder)?;

        let target = unsafe { target.deref_unchecked() };

        if target.len() > 4095 {
            return Err(::fidl_next::DecodeError::VectorTooLong {
                size: target.len() as u64,
                limit: 4095,
            });
        }

        Ok(())
    }
}

#[derive(Debug)]
pub enum NodeInfoDeprecated {
    Service(crate::Service),

    File(crate::FileObject),

    Directory(crate::DirectoryObject),

    Symlink(crate::SymlinkObject),
}

impl ::fidl_next::Encodable for NodeInfoDeprecated {
    type Encoded = WireNodeInfoDeprecated;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeInfoDeprecated
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeInfoDeprecated { raw } = out);

        match self {
            Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::Service>(
                value, 1, encoder, raw,
            )?,

            Self::File(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::FileObject>(
                value, 2, encoder, raw,
            )?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DirectoryObject,
            >(value, 3, encoder, raw)?,

            Self::Symlink(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::SymlinkObject,
            >(value, 4, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeInfoDeprecated> {
    type EncodedOption = WireOptionalNodeInfoDeprecated;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<NodeInfoDeprecated>
where
    ___E: ?Sized,
    NodeInfoDeprecated: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalNodeInfoDeprecated { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeInfoDeprecated> for NodeInfoDeprecated {
    #[inline]
    fn take_from(from: &WireNodeInfoDeprecated) -> Self {
        match from.raw.ordinal() {
            1 => Self::Service(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireService>()
            })),

            2 => Self::File(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireFileObject>()
            })),

            3 => Self::Directory(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirectoryObject>()
            })),

            4 => Self::Symlink(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireSymlinkObject>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalNodeInfoDeprecated> for Option<Box<NodeInfoDeprecated>> {
    #[inline]
    fn take_from(from: &WireOptionalNodeInfoDeprecated) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`NodeInfoDeprecated`].
#[repr(transparent)]
pub struct WireNodeInfoDeprecated {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireNodeInfoDeprecated {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod node_info_deprecated {
    pub enum Ref<'union> {
        Service(&'union crate::WireService),

        File(&'union crate::WireFileObject),

        Directory(&'union crate::WireDirectoryObject),

        Symlink(&'union crate::WireSymlinkObject),
    }
}

impl WireNodeInfoDeprecated {
    pub fn as_ref(&self) -> crate::node_info_deprecated::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::node_info_deprecated::Ref::Service(unsafe {
                self.raw.get().deref_unchecked::<crate::WireService>()
            }),

            2 => crate::node_info_deprecated::Ref::File(unsafe {
                self.raw.get().deref_unchecked::<crate::WireFileObject>()
            }),

            3 => crate::node_info_deprecated::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirectoryObject>()
            }),

            4 => crate::node_info_deprecated::Ref::Symlink(unsafe {
                self.raw.get().deref_unchecked::<crate::WireSymlinkObject>()
            }),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeInfoDeprecated
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireService>(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileObject>(raw, decoder)?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryObject>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkObject>(
                raw, decoder,
            )?,

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireNodeInfoDeprecated {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireService>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireFileObject>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirectoryObject>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireSymlinkObject>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalNodeInfoDeprecated {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalNodeInfoDeprecated {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalNodeInfoDeprecated {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> Option<&WireNodeInfoDeprecated> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalNodeInfoDeprecated
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireService>(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileObject>(raw, decoder)?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryObject>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkObject>(
                raw, decoder,
            )?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalNodeInfoDeprecated {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " Flags used when opening a node reference must fall within this mask.\n"]
pub const OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE: crate::OpenFlags =
    crate::OpenFlags::from_bits_retain(46661632);

#[doc = " All known rights.\n"]
pub const OPEN_RIGHTS: crate::OpenFlags = crate::OpenFlags::from_bits_retain(11);

#[doc = " Set of permissions that are expected when opening a node as executable.\n"]
pub const PERM_EXECUTABLE: crate::Flags = crate::Flags::from_bits_retain(201);

#[doc = " Set of permissions that are expected when opening a node as readable.\n"]
pub const PERM_READABLE: crate::Flags = crate::Flags::from_bits_retain(211);

#[doc = " Set of permissions that are expected when opening a node as writable.\n"]
pub const PERM_WRITABLE: crate::Flags = crate::Flags::from_bits_retain(485);

#[doc = " Alias for directory permission alias rw*\n"]
pub const RW_STAR_DIR: crate::Operations = crate::Operations::from_bits_retain(503);

#[doc = " Alias for directory permission alias rx*\n"]
pub const RX_STAR_DIR: crate::Operations = crate::Operations::from_bits_retain(219);

#[doc = " Alias for directory permission alias r*\n"]
pub const R_STAR_DIR: crate::Operations = crate::Operations::from_bits_retain(211);

#[doc = " The name of the extended attribute accessible via the SELinux context attribute.\n"]
pub const SELINUX_CONTEXT_NAME: &str = "security.selinux";

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

/// The type corresponding to the Symlink protocol.
#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
#[derive(Debug)]
pub struct Symlink;

impl ::fidl_next::Discoverable for Symlink {
    const PROTOCOL_NAME: &'static str = "symlink";
}

pub mod symlink {
    pub mod prelude {
        pub use crate::{
            symlink, Symlink, SymlinkClientHandler, SymlinkClientSender, SymlinkServerHandler,
            SymlinkServerSender,
        };

        pub use crate::ConnectionInfo;

        pub use crate::ExtendedAttributeValue;

        pub use crate::LinkableLinkIntoRequest;

        pub use crate::LinkableLinkIntoResponse;

        pub use crate::MutableNodeAttributes;

        pub use crate::NodeAttributes2;

        pub use crate::NodeDeprecatedCloneRequest;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        pub use crate::NodeGetAttrResponse;

        pub use crate::NodeGetAttributesRequest;

        pub use crate::NodeGetExtendedAttributeRequest;

        pub use crate::NodeListExtendedAttributesRequest;

        pub use crate::NodeOnOpenRequest;

        pub use crate::NodeQueryFilesystemResponse;

        pub use crate::NodeRemoveExtendedAttributeRequest;

        pub use crate::NodeSetAttrRequest;

        pub use crate::NodeSetAttrResponse;

        pub use crate::NodeSetExtendedAttributeRequest;

        pub use crate::NodeSetFlagsRequest;

        pub use crate::NodeGetFlagsResponse;

        pub use crate::NodeRemoveExtendedAttributeResponse;

        pub use crate::NodeSetExtendedAttributeResponse;

        pub use crate::NodeSetFlagsResponse;

        pub use crate::NodeSyncResponse;

        pub use crate::NodeUpdateAttributesResponse;

        pub use crate::Representation;

        pub use crate::SymlinkInfo;

        pub use ::fidl_next_fuchsia_unknown::CloneableCloneRequest;

        pub use ::fidl_next_fuchsia_unknown::CloseableCloseResponse;

        pub use ::fidl_next_fuchsia_unknown::QueryableQueryResponse;
    }

    pub struct LinkInto;

    impl ::fidl_next::Method for LinkInto {
        const ORDINAL: u64 = 6121399674497678964;

        type Protocol = crate::Symlink;

        type Request = crate::WireLinkableLinkIntoRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireLinkableLinkIntoResponse, ::fidl_next::WireI32>;
    }

    pub struct Clone;

    impl ::fidl_next::Method for Clone {
        const ORDINAL: u64 = 2366825959783828089;

        type Protocol = crate::Symlink;

        type Request = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct Close;

    impl ::fidl_next::Method for Close {
        const ORDINAL: u64 = 6540867515453498750;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            ::fidl_next_fuchsia_unknown::WireCloseableCloseResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Query;

    impl ::fidl_next::Method for Query {
        const ORDINAL: u64 = 2763219980499352582;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = ::fidl_next_fuchsia_unknown::WireQueryableQueryResponse;
    }

    pub struct DeprecatedClone;

    impl ::fidl_next::Method for DeprecatedClone {
        const ORDINAL: u64 = 6512600400724287855;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeDeprecatedCloneRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct OnOpen;

    impl ::fidl_next::Method for OnOpen {
        const ORDINAL: u64 = 9207534335756671346;

        type Protocol = crate::Symlink;

        type Request = ::fidl_next::Never;

        type Response = crate::WireNodeOnOpenRequest;
    }

    pub struct GetAttr;

    impl ::fidl_next::Method for GetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = crate::WireNodeGetAttrResponse;
    }

    pub struct SetAttr;

    impl ::fidl_next::Method for SetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeSetAttrRequest;

        type Response = crate::WireNodeSetAttrResponse;
    }

    pub struct DeprecatedGetFlags;

    impl ::fidl_next::Method for DeprecatedGetFlags {
        const ORDINAL: u64 = 6595803110182632097;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetFlagsResponse;
    }

    pub struct DeprecatedSetFlags;

    impl ::fidl_next::Method for DeprecatedSetFlags {
        const ORDINAL: u64 = 5950864159036794675;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeDeprecatedSetFlagsRequest;

        type Response = crate::WireNodeDeprecatedSetFlagsResponse;
    }

    pub struct GetFlags;

    impl ::fidl_next::Method for GetFlags {
        const ORDINAL: u64 = 105530239381466147;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeGetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct SetFlags;

    impl ::fidl_next::Method for SetFlags {
        const ORDINAL: u64 = 6172186066099445416;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeSetFlagsRequest;

        type Response =
            ::fidl_next::WireFlexibleResult<crate::WireNodeSetFlagsResponse, ::fidl_next::WireI32>;
    }

    pub struct QueryFilesystem;

    impl ::fidl_next::Method for QueryFilesystem {
        const ORDINAL: u64 = 8013111122914313744;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = crate::WireNodeQueryFilesystemResponse;
    }

    pub struct OnRepresentation;

    impl ::fidl_next::Method for OnRepresentation {
        const ORDINAL: u64 = 6679970090861613324;

        type Protocol = crate::Symlink;

        type Request = ::fidl_next::Never;

        type Response = crate::WireRepresentation;
    }

    pub struct GetConnectionInfo;

    impl ::fidl_next::Method for GetConnectionInfo {
        const ORDINAL: u64 = 6362521381364198667;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = crate::WireConnectionInfo;
    }

    pub struct GetAttributes;

    impl ::fidl_next::Method for GetAttributes {
        const ORDINAL: u64 = 4414537700416816443;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeGetAttributesRequest;

        type Response = ::fidl_next::WireResult<crate::WireNodeAttributes2, ::fidl_next::WireI32>;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Symlink;

        type Request = crate::WireMutableNodeAttributes;

        type Response =
            ::fidl_next::WireResult<crate::WireNodeUpdateAttributesResponse, ::fidl_next::WireI32>;
    }

    pub struct Sync;

    impl ::fidl_next::Method for Sync {
        const ORDINAL: u64 = 3196473584242777161;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = ::fidl_next::WireResult<crate::WireNodeSyncResponse, ::fidl_next::WireI32>;
    }

    pub struct ListExtendedAttributes;

    impl ::fidl_next::Method for ListExtendedAttributes {
        const ORDINAL: u64 = 5431626189872037072;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeListExtendedAttributesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct GetExtendedAttribute;

    impl ::fidl_next::Method for GetExtendedAttribute {
        const ORDINAL: u64 = 5043930208506967771;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeGetExtendedAttributeRequest;

        type Response =
            ::fidl_next::WireResult<crate::WireExtendedAttributeValue, ::fidl_next::WireI32>;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeSetExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeSetExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct RemoveExtendedAttribute;

    impl ::fidl_next::Method for RemoveExtendedAttribute {
        const ORDINAL: u64 = 8794297771444732717;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeRemoveExtendedAttributeRequest;

        type Response = ::fidl_next::WireResult<
            crate::WireNodeRemoveExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Describe;

    impl ::fidl_next::Method for Describe {
        const ORDINAL: u64 = 8371117097481679347;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<crate::WireSymlinkInfo>;
    }
}

/// A helper trait for the `Symlink` client sender.
pub trait SymlinkClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >;

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >;

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Close>,
        ::fidl_next::EncodeError,
    >;

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Query>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >;

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetAttr>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >;

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetFlags>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::QueryFilesystem>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >;

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >;

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Sync>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >;

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >;

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >;

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >;

    fn describe(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Describe>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> SymlinkClientSender for ::fidl_next::ClientSender<___T, Symlink>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
    fn link_into<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::LinkInto>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLinkableLinkIntoRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6121399674497678964, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(2366825959783828089, request)
    }

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Close>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6540867515453498750, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn query(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Query>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2763219980499352582, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedCloneRequest,
        >,
    {
        self.as_untyped().send_one_way(6512600400724287855, request)
    }

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetAttr>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8689798978500614909, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetAttr>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetAttrRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4721673413776871238, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::DeprecatedGetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6595803110182632097, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::DeprecatedSetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5950864159036794675, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetFlags>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(105530239381466147, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetFlags>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetFlagsRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6172186066099445416, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::QueryFilesystem>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8013111122914313744, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetConnectionInfo>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(6362521381364198667, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetAttributesRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4414537700416816443, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::UpdateAttributes>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireMutableNodeAttributes,
        >,
    {
        self.as_untyped()
            .send_two_way(3677402239314018056, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Sync>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(3196473584242777161, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeListExtendedAttributesRequest,
        >,
    {
        self.as_untyped().send_one_way(5431626189872037072, request)
    }

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::GetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeGetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5043930208506967771, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::SetExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeSetExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5374223046099989052, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::RemoveExtendedAttribute>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeRemoveExtendedAttributeRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8794297771444732717, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn describe(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, symlink::Describe>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8371117097481679347, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Symlink protocol.
///
/// See [`Symlink`] for more details.
pub trait SymlinkClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
    fn on_open(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Symlink>,

        message: ::fidl_next::ResponseBuffer<___T, symlink::OnOpen>,
    );

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
    fn on_representation(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Symlink>,

        message: ::fidl_next::ResponseBuffer<___T, symlink::OnRepresentation>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Symlink>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Symlink
where
    ___T: ::fidl_next::Transport,
    ___H: SymlinkClientHandler<___T>,

    <symlink::LinkInto as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::Close as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::Query as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::OnOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::SetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedGetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedSetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::SetFlags as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::QueryFilesystem as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::OnRepresentation as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetConnectionInfo as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::UpdateAttributes as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::Sync as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::SetExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::RemoveExtendedAttribute as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::Describe as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_open(sender, buffer);
            }

            6679970090861613324 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_representation(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `Symlink` server sender.
pub trait SymlinkServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <symlink::OnOpen as ::fidl_next::Method>::Response,
        >;

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <symlink::OnRepresentation as ::fidl_next::Method>::Response,
        >;
}

impl<___T> SymlinkServerSender for ::fidl_next::ServerSender<___T, Symlink>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]

    fn on_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <symlink::OnOpen as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(9207534335756671346, request)
    }

    #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]

    fn on_representation<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <symlink::OnRepresentation as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(6679970090861613324, request)
    }
}

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

        request: ::fidl_next::RequestBuffer<___T, symlink::LinkInto>,

        responder: ::fidl_next::Responder<symlink::LinkInto>,
    );

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::Clone>,
    );

    #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
    fn close(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::Close>,
    );

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::Query>,
    );

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::DeprecatedClone>,
    );

    #[doc = " Acquires information about the node.\n\n This method does not require any rights.\n"]
    fn get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::GetAttr>,
    );

    #[doc = " Updates information about the node.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if any attributes specified by [`flags`] are not supported.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n"]
    fn set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::SetAttr>,

        responder: ::fidl_next::Responder<symlink::SetAttr>,
    );

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags>,
    );

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::DeprecatedSetFlags>,

        responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags>,
    );

    #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n  - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n  - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n  - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
    fn get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::GetFlags>,
    );

    #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n  - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n  - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
    fn set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::SetFlags>,

        responder: ::fidl_next::Responder<symlink::SetFlags>,
    );

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::QueryFilesystem>,
    );

    #[doc = " Acquires information about the connection.\n\n This method does not require any rights.\n"]
    fn get_connection_info(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::GetConnectionInfo>,
    );

    #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n   should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::GetAttributes>,

        responder: ::fidl_next::Responder<symlink::GetAttributes>,
    );

    #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn update_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::UpdateAttributes>,

        responder: ::fidl_next::Responder<symlink::UpdateAttributes>,
    );

    #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
    fn sync(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::Sync>,
    );

    #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn list_extended_attributes(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::ListExtendedAttributes>,
    );

    #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
    fn get_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::GetExtendedAttribute>,

        responder: ::fidl_next::Responder<symlink::GetExtendedAttribute>,
    );

    #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn set_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::SetExtendedAttribute>,

        responder: ::fidl_next::Responder<symlink::SetExtendedAttribute>,
    );

    #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
    fn remove_extended_attribute(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        request: ::fidl_next::RequestBuffer<___T, symlink::RemoveExtendedAttribute>,

        responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute>,
    );

    fn describe(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,

        responder: ::fidl_next::Responder<symlink::Describe>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Symlink>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Symlink
where
    ___T: ::fidl_next::Transport,
    ___H: SymlinkServerHandler<___T>,

    crate::WireLinkableLinkIntoRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedCloneRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetAttrRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeDeprecatedSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetFlagsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireMutableNodeAttributes:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeListExtendedAttributesRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeGetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeSetExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireNodeRemoveExtendedAttributeRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.clone(sender, buffer);
            }

            6512600400724287855 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_clone(sender, buffer);
            }

            5431626189872037072 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.list_extended_attributes(sender, buffer);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            6121399674497678964 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.link_into(sender, buffer, responder);
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder);
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder);
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_attr(sender, responder);
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_attr(sender, buffer, responder);
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder);
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.deprecated_set_flags(sender, buffer, responder);
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder);
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_flags(sender, buffer, responder);
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder);
            }

            6362521381364198667 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_connection_info(sender, responder);
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_attributes(sender, buffer, responder);
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.update_attributes(sender, buffer, responder);
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder);
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.get_extended_attribute(sender, buffer, responder);
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_extended_attribute(sender, buffer, responder);
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.remove_extended_attribute(sender, buffer, responder);
            }

            8371117097481679347 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.describe(sender, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[doc = " Alias for directory permission alias w*\n"]
pub const W_STAR_DIR: crate::Operations = crate::Operations::from_bits_retain(485);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum WatchEvent {
    Deleted = 0,
    Added = 1,
    Removed = 2,
    Existing = 3,
    Idle = 4,
}

impl ::fidl_next::Encodable for WatchEvent {
    type Encoded = WireWatchEvent;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for WatchEvent
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireWatchEvent { value } = out);
        let _ = value.write(u8::from(match *self {
            Self::Deleted => 0,

            Self::Added => 1,

            Self::Removed => 2,

            Self::Existing => 3,

            Self::Idle => 4,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireWatchEvent> for WatchEvent {
    fn from(wire: WireWatchEvent) -> Self {
        match u8::from(wire.value) {
            0 => Self::Deleted,

            1 => Self::Added,

            2 => Self::Removed,

            3 => Self::Existing,

            4 => Self::Idle,

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireWatchEvent> for WatchEvent {
    #[inline]
    fn take_from(from: &WireWatchEvent) -> Self {
        Self::from(*from)
    }
}

/// The wire type corresponding to [`WatchEvent`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireWatchEvent {
    value: u8,
}

unsafe impl ::fidl_next::ZeroPadding for WireWatchEvent {
    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireWatchEvent {
    pub const DELETED: WireWatchEvent = WireWatchEvent { value: 0 };

    pub const ADDED: WireWatchEvent = WireWatchEvent { value: 1 };

    pub const REMOVED: WireWatchEvent = WireWatchEvent { value: 2 };

    pub const EXISTING: WireWatchEvent = WireWatchEvent { value: 3 };

    pub const IDLE: WireWatchEvent = WireWatchEvent { value: 4 };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWatchEvent
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);

        match u8::from(*value) {
            0 | 1 | 2 | 3 | 4 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

impl ::core::convert::From<WatchEvent> for WireWatchEvent {
    fn from(natural: WatchEvent) -> Self {
        match natural {
            WatchEvent::Deleted => WireWatchEvent::DELETED,

            WatchEvent::Added => WireWatchEvent::ADDED,

            WatchEvent::Removed => WireWatchEvent::REMOVED,

            WatchEvent::Existing => WireWatchEvent::EXISTING,

            WatchEvent::Idle => WireWatchEvent::IDLE,
        }
    }
}

#[doc = " Alias for directory permission alias x*\n"]
pub const X_STAR_DIR: crate::Operations = crate::Operations::from_bits_retain(201);

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::fidl_next::TakeFrom<crate::WireOperations> for ::fidl_fuchsia_io::Operations {
        #[inline]
        fn take_from(from: &crate::WireOperations) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSeekOrigin> for ::fidl_fuchsia_io::SeekOrigin {
        #[inline]
        fn take_from(from: &crate::WireSeekOrigin) -> Self {
            match crate::SeekOrigin::from(*from) {
                crate::SeekOrigin::Start => Self::Start,

                crate::SeekOrigin::Current => Self::Current,

                crate::SeekOrigin::End => Self::End,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAdvisoryLockRange> for ::fidl_fuchsia_io::AdvisoryLockRange {
        #[inline]
        fn take_from(from: &crate::WireAdvisoryLockRange) -> Self {
            Self {
                origin: ::fidl_next::TakeFrom::take_from(&from.origin),

                offset: ::fidl_next::TakeFrom::take_from(&from.offset),

                length: ::fidl_next::TakeFrom::take_from(&from.length),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAdvisoryLockType> for ::fidl_fuchsia_io::AdvisoryLockType {
        #[inline]
        fn take_from(from: &crate::WireAdvisoryLockType) -> Self {
            match crate::AdvisoryLockType::from(*from) {
                crate::AdvisoryLockType::Read => Self::Read,

                crate::AdvisoryLockType::Write => Self::Write,

                crate::AdvisoryLockType::Unlock => Self::Unlock,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAdvisoryLockRequest>
        for ::fidl_fuchsia_io::AdvisoryLockRequest
    {
        #[inline]
        fn take_from(from: &crate::WireAdvisoryLockRequest) -> Self {
            Self {
                type_: from.type_().map(::fidl_next::TakeFrom::take_from),

                range: from.range().map(::fidl_next::TakeFrom::take_from),

                wait: from.wait().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAdvisoryLockingAdvisoryLockRequest>
        for ::fidl_fuchsia_io::AdvisoryLockingAdvisoryLockRequest
    {
        #[inline]
        fn take_from(from: &crate::WireAdvisoryLockingAdvisoryLockRequest) -> Self {
            Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `AdvisoryLocking`
    /// protocol.
    pub type AdvisoryLockingProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::AdvisoryLocking>;

    impl ::fidl_next::TakeFrom<crate::AdvisoryLocking> for ::fidl_fuchsia_io::AdvisoryLockingMarker {
        #[inline]
        fn take_from(from: &crate::AdvisoryLocking) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAllocateMode> for ::fidl_fuchsia_io::AllocateMode {
        #[inline]
        fn take_from(from: &crate::WireAllocateMode) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConnectionInfo> for ::fidl_fuchsia_io::ConnectionInfo {
        #[inline]
        fn take_from(from: &crate::WireConnectionInfo) -> Self {
            Self {
                rights: from.rights().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOpenFlags> for ::fidl_fuchsia_io::OpenFlags {
        #[inline]
        fn take_from(from: &crate::WireOpenFlags) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAttributes> for ::fidl_fuchsia_io::NodeAttributes {
        #[inline]
        fn take_from(from: &crate::WireNodeAttributes) -> Self {
            Self {
                mode: ::fidl_next::TakeFrom::take_from(&from.mode),

                id: ::fidl_next::TakeFrom::take_from(&from.id),

                content_size: ::fidl_next::TakeFrom::take_from(&from.content_size),

                storage_size: ::fidl_next::TakeFrom::take_from(&from.storage_size),

                link_count: ::fidl_next::TakeFrom::take_from(&from.link_count),

                creation_time: ::fidl_next::TakeFrom::take_from(&from.creation_time),

                modification_time: ::fidl_next::TakeFrom::take_from(&from.modification_time),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeGetAttrResponse>
        for ::fidl_fuchsia_io::NodeGetAttrResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeGetAttrResponse) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAttributeFlags>
        for ::fidl_fuchsia_io::NodeAttributeFlags
    {
        #[inline]
        fn take_from(from: &crate::WireNodeAttributeFlags) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeSetAttrRequest>
        for ::fidl_fuchsia_io::NodeSetAttrRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeSetAttrRequest) -> Self {
            Self {
                flags: ::fidl_next::TakeFrom::take_from(&from.flags),

                attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeSetAttrResponse>
        for ::fidl_fuchsia_io::NodeSetAttrResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeSetAttrResponse) -> Self {
            Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeQueryFilesystemResponse>
        for ::fidl_fuchsia_io::NodeQueryFilesystemResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeQueryFilesystemResponse) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                info: ::fidl_next::TakeFrom::take_from(&from.info),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireModeType> for ::fidl_fuchsia_io::ModeType {
        #[inline]
        fn take_from(from: &crate::WireModeType) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryReadDirentsRequest>
        for ::fidl_fuchsia_io::DirectoryReadDirentsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryReadDirentsRequest) -> Self {
            Self { max_bytes: ::fidl_next::TakeFrom::take_from(&from.max_bytes) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryReadDirentsResponse>
        for ::fidl_fuchsia_io::DirectoryReadDirentsResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryReadDirentsResponse) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                dirents: ::fidl_next::TakeFrom::take_from(&from.dirents),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryRewindResponse>
        for ::fidl_fuchsia_io::DirectoryRewindResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryRewindResponse) -> Self {
            Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryGetTokenResponse>
        for ::fidl_fuchsia_io::DirectoryGetTokenResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryGetTokenResponse) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                token: ::fidl_next::TakeFrom::take_from(&from.token),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryLinkRequest>
        for ::fidl_fuchsia_io::DirectoryLinkRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryLinkRequest) -> Self {
            Self {
                src: ::fidl_next::TakeFrom::take_from(&from.src),

                dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

                dst: ::fidl_next::TakeFrom::take_from(&from.dst),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryLinkResponse>
        for ::fidl_fuchsia_io::DirectoryLinkResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryLinkResponse) -> Self {
            Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUnlinkFlags> for ::fidl_fuchsia_io::UnlinkFlags {
        #[inline]
        fn take_from(from: &crate::WireUnlinkFlags) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUnlinkOptions> for ::fidl_fuchsia_io::UnlinkOptions {
        #[inline]
        fn take_from(from: &crate::WireUnlinkOptions) -> Self {
            Self {
                flags: from.flags().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryUnlinkRequest>
        for ::fidl_fuchsia_io::DirectoryUnlinkRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryUnlinkRequest) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

                options: ::fidl_next::TakeFrom::take_from(&from.options),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryRenameRequest>
        for ::fidl_fuchsia_io::DirectoryRenameRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryRenameRequest) -> Self {
            Self {
                src: ::fidl_next::TakeFrom::take_from(&from.src),

                dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

                dst: ::fidl_next::TakeFrom::take_from(&from.dst),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireWatchMask> for ::fidl_fuchsia_io::WatchMask {
        #[inline]
        fn take_from(from: &crate::WireWatchMask) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryWatchRequest>
        for ::fidl_fuchsia_io::DirectoryWatchRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryWatchRequest) -> Self {
            Self {
                mask: ::fidl_next::TakeFrom::take_from(&from.mask),

                options: ::fidl_next::TakeFrom::take_from(&from.options),

                watcher: ::fidl_next::TakeFrom::take_from(&from.watcher),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryWatchResponse>
        for ::fidl_fuchsia_io::DirectoryWatchResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryWatchResponse) -> Self {
            Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeOnOpenRequest> for ::fidl_fuchsia_io::NodeOnOpenRequest {
        #[inline]
        fn take_from(from: &crate::WireNodeOnOpenRequest) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                info: ::fidl_next::TakeFrom::take_from(&from.info),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeListExtendedAttributesRequest>
        for ::fidl_fuchsia_io::NodeListExtendedAttributesRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeListExtendedAttributesRequest) -> Self {
            Self { iterator: ::fidl_next::TakeFrom::take_from(&from.iterator) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeGetExtendedAttributeRequest>
        for ::fidl_fuchsia_io::NodeGetExtendedAttributeRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeGetExtendedAttributeRequest) -> Self {
            Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExtendedAttributeValue>
        for ::fidl_fuchsia_io::ExtendedAttributeValue
    {
        #[inline]
        fn take_from(from: &crate::WireExtendedAttributeValue) -> Self {
            match from.as_ref() {
                crate::extended_attribute_value::Ref::Bytes(value) => {
                    Self::Bytes(::fidl_next::TakeFrom::take_from(value))
                }

                crate::extended_attribute_value::Ref::Buffer(value) => {
                    Self::Buffer(::fidl_next::TakeFrom::take_from(value))
                }

                crate::extended_attribute_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalExtendedAttributeValue>
        for Option<Box<::fidl_fuchsia_io::ExtendedAttributeValue>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalExtendedAttributeValue) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSetExtendedAttributeMode>
        for ::fidl_fuchsia_io::SetExtendedAttributeMode
    {
        #[inline]
        fn take_from(from: &crate::WireSetExtendedAttributeMode) -> Self {
            match crate::SetExtendedAttributeMode::from(*from) {
                crate::SetExtendedAttributeMode::Set => Self::Set,

                crate::SetExtendedAttributeMode::Create => Self::Create,

                crate::SetExtendedAttributeMode::Replace => Self::Replace,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeSetExtendedAttributeRequest>
        for ::fidl_fuchsia_io::NodeSetExtendedAttributeRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeSetExtendedAttributeRequest) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

                value: ::fidl_next::TakeFrom::take_from(&from.value),

                mode: ::fidl_next::TakeFrom::take_from(&from.mode),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeRemoveExtendedAttributeRequest>
        for ::fidl_fuchsia_io::NodeRemoveExtendedAttributeRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeRemoveExtendedAttributeRequest) -> Self {
            Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeDeprecatedCloneRequest>
        for ::fidl_fuchsia_io::NodeDeprecatedCloneRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeDeprecatedCloneRequest) -> Self {
            Self {
                flags: ::fidl_next::TakeFrom::take_from(&from.flags),

                object: ::fidl_next::TakeFrom::take_from(&from.object),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeDeprecatedGetFlagsResponse>
        for ::fidl_fuchsia_io::NodeDeprecatedGetFlagsResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeDeprecatedGetFlagsResponse) -> Self {
            Self {
                s: ::fidl_next::TakeFrom::take_from(&from.s),

                flags: ::fidl_next::TakeFrom::take_from(&from.flags),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeDeprecatedSetFlagsRequest>
        for ::fidl_fuchsia_io::NodeDeprecatedSetFlagsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeDeprecatedSetFlagsRequest) -> Self {
            Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeDeprecatedSetFlagsResponse>
        for ::fidl_fuchsia_io::NodeDeprecatedSetFlagsResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeDeprecatedSetFlagsResponse) -> Self {
            Self { s: ::fidl_next::TakeFrom::take_from(&from.s) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFlags> for ::fidl_fuchsia_io::Flags {
        #[inline]
        fn take_from(from: &crate::WireFlags) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeGetFlagsResponse>
        for ::fidl_fuchsia_io::NodeGetFlagsResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNodeGetFlagsResponse) -> Self {
            Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeSetFlagsRequest>
        for ::fidl_fuchsia_io::NodeSetFlagsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeSetFlagsRequest) -> Self {
            Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEmptyStruct> for ::fidl_fuchsia_io::EmptyStruct {
        #[inline]
        fn take_from(from: &crate::WireEmptyStruct) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSelinuxContext> for ::fidl_fuchsia_io::SelinuxContext {
        #[inline]
        fn take_from(from: &crate::WireSelinuxContext) -> Self {
            match from.as_ref() {
                crate::selinux_context::Ref::Data(value) => {
                    Self::Data(::fidl_next::TakeFrom::take_from(value))
                }

                crate::selinux_context::Ref::UseExtendedAttributes(value) => {
                    Self::UseExtendedAttributes(::fidl_next::TakeFrom::take_from(value))
                }

                crate::selinux_context::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalSelinuxContext>
        for Option<Box<::fidl_fuchsia_io::SelinuxContext>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalSelinuxContext) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireMutableNodeAttributes>
        for ::fidl_fuchsia_io::MutableNodeAttributes
    {
        #[inline]
        fn take_from(from: &crate::WireMutableNodeAttributes) -> Self {
            Self {
                creation_time: from.creation_time().map(::fidl_next::TakeFrom::take_from),

                modification_time: from.modification_time().map(::fidl_next::TakeFrom::take_from),

                mode: from.mode().map(::fidl_next::TakeFrom::take_from),

                uid: from.uid().map(::fidl_next::TakeFrom::take_from),

                gid: from.gid().map(::fidl_next::TakeFrom::take_from),

                rdev: from.rdev().map(::fidl_next::TakeFrom::take_from),

                access_time: from.access_time().map(::fidl_next::TakeFrom::take_from),

                casefold: from.casefold().map(::fidl_next::TakeFrom::take_from),

                selinux_context: from.selinux_context().map(::fidl_next::TakeFrom::take_from),

                wrapping_key_id: from.wrapping_key_id().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeProtocolKinds> for ::fidl_fuchsia_io::NodeProtocolKinds {
        #[inline]
        fn take_from(from: &crate::WireNodeProtocolKinds) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireHashAlgorithm> for ::fidl_fuchsia_io::HashAlgorithm {
        #[inline]
        fn take_from(from: &crate::WireHashAlgorithm) -> Self {
            match crate::HashAlgorithm::from(*from) {
                crate::HashAlgorithm::Sha256 => Self::Sha256,

                crate::HashAlgorithm::Sha512 => Self::Sha512,

                crate::HashAlgorithm::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireVerificationOptions>
        for ::fidl_fuchsia_io::VerificationOptions
    {
        #[inline]
        fn take_from(from: &crate::WireVerificationOptions) -> Self {
            Self {
                hash_algorithm: from.hash_algorithm().map(::fidl_next::TakeFrom::take_from),

                salt: from.salt().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireImmutableNodeAttributes>
        for ::fidl_fuchsia_io::ImmutableNodeAttributes
    {
        #[inline]
        fn take_from(from: &crate::WireImmutableNodeAttributes) -> Self {
            Self {
                protocols: from.protocols().map(::fidl_next::TakeFrom::take_from),

                abilities: from.abilities().map(::fidl_next::TakeFrom::take_from),

                content_size: from.content_size().map(::fidl_next::TakeFrom::take_from),

                storage_size: from.storage_size().map(::fidl_next::TakeFrom::take_from),

                link_count: from.link_count().map(::fidl_next::TakeFrom::take_from),

                id: from.id().map(::fidl_next::TakeFrom::take_from),

                change_time: from.change_time().map(::fidl_next::TakeFrom::take_from),

                options: from.options().map(::fidl_next::TakeFrom::take_from),

                root_hash: from.root_hash().map(::fidl_next::TakeFrom::take_from),

                verity_enabled: from.verity_enabled().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAttributes2> for ::fidl_fuchsia_io::NodeAttributes2 {
        #[inline]
        fn take_from(from: &crate::WireNodeAttributes2) -> Self {
            Self {
                mutable_attributes: ::fidl_next::TakeFrom::take_from(&from.mutable_attributes),

                immutable_attributes: ::fidl_next::TakeFrom::take_from(&from.immutable_attributes),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeInfo> for ::fidl_fuchsia_io::NodeInfo {
        #[inline]
        fn take_from(from: &crate::WireNodeInfo) -> Self {
            Self {
                attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryInfo> for ::fidl_fuchsia_io::DirectoryInfo {
        #[inline]
        fn take_from(from: &crate::WireDirectoryInfo) -> Self {
            Self {
                attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileInfo> for ::fidl_fuchsia_io::FileInfo {
        #[inline]
        fn take_from(from: &crate::WireFileInfo) -> Self {
            Self {
                is_append: from.is_append().map(::fidl_next::TakeFrom::take_from),

                observer: from.observer().map(::fidl_next::TakeFrom::take_from),

                stream: from.stream().map(::fidl_next::TakeFrom::take_from),

                attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSymlinkInfo> for ::fidl_fuchsia_io::SymlinkInfo {
        #[inline]
        fn take_from(from: &crate::WireSymlinkInfo) -> Self {
            Self {
                target: from.target().map(::fidl_next::TakeFrom::take_from),

                attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRepresentation> for ::fidl_fuchsia_io::Representation {
        #[inline]
        fn take_from(from: &crate::WireRepresentation) -> Self {
            match from.as_ref() {
                crate::representation::Ref::Node(value) => {
                    Self::Node(::fidl_next::TakeFrom::take_from(value))
                }

                crate::representation::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::representation::Ref::File(value) => {
                    Self::File(::fidl_next::TakeFrom::take_from(value))
                }

                crate::representation::Ref::Symlink(value) => {
                    Self::Symlink(::fidl_next::TakeFrom::take_from(value))
                }

                crate::representation::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalRepresentation>
        for Option<Box<::fidl_fuchsia_io::Representation>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalRepresentation) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAttributesQuery>
        for ::fidl_fuchsia_io::NodeAttributesQuery
    {
        #[inline]
        fn take_from(from: &crate::WireNodeAttributesQuery) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeGetAttributesRequest>
        for ::fidl_fuchsia_io::NodeGetAttributesRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeGetAttributesRequest) -> Self {
            Self { query: ::fidl_next::TakeFrom::take_from(&from.query) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Node`
    /// protocol.
    pub type NodeProxy = ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Node>;

    impl ::fidl_next::TakeFrom<crate::Node> for ::fidl_fuchsia_io::NodeMarker {
        #[inline]
        fn take_from(from: &crate::Node) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryDeprecatedOpenRequest>
        for ::fidl_fuchsia_io::DirectoryDeprecatedOpenRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryDeprecatedOpenRequest) -> Self {
            Self {
                flags: ::fidl_next::TakeFrom::take_from(&from.flags),

                mode: ::fidl_next::TakeFrom::take_from(&from.mode),

                path: ::fidl_next::TakeFrom::take_from(&from.path),

                object: ::fidl_next::TakeFrom::take_from(&from.object),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptions> for ::fidl_fuchsia_io::Options {
        #[inline]
        fn take_from(from: &crate::WireOptions) -> Self {
            Self {
                attributes: from.attributes().map(::fidl_next::TakeFrom::take_from),

                create_attributes: from.create_attributes().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryOpenRequest>
        for ::fidl_fuchsia_io::DirectoryOpenRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryOpenRequest) -> Self {
            Self {
                path: ::fidl_next::TakeFrom::take_from(&from.path),

                flags: ::fidl_next::TakeFrom::take_from(&from.flags),

                options: ::fidl_next::TakeFrom::take_from(&from.options),

                object: ::fidl_next::TakeFrom::take_from(&from.object),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryCreateSymlinkRequest>
        for ::fidl_fuchsia_io::DirectoryCreateSymlinkRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryCreateSymlinkRequest) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

                target: ::fidl_next::TakeFrom::take_from(&from.target),

                connection: ::fidl_next::TakeFrom::take_from(&from.connection),
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Directory`
    /// protocol.
    pub type DirectoryProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Directory>;

    impl ::fidl_next::TakeFrom<crate::Directory> for ::fidl_fuchsia_io::DirectoryMarker {
        #[inline]
        fn take_from(from: &crate::Directory) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryObject> for ::fidl_fuchsia_io::DirectoryObject {
        #[inline]
        fn take_from(from: &crate::WireDirectoryObject) -> Self {
            Self {}
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DirectoryWatcher`
    /// protocol.
    pub type DirectoryWatcherProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DirectoryWatcher>;

    impl ::fidl_next::TakeFrom<crate::DirectoryWatcher> for ::fidl_fuchsia_io::DirectoryWatcherMarker {
        #[inline]
        fn take_from(from: &crate::DirectoryWatcher) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirentType> for ::fidl_fuchsia_io::DirentType {
        #[inline]
        fn take_from(from: &crate::WireDirentType) -> Self {
            match crate::DirentType::from(*from) {
                crate::DirentType::Unknown => Self::Unknown,

                crate::DirentType::Directory => Self::Directory,

                crate::DirentType::BlockDevice => Self::BlockDevice,

                crate::DirentType::File => Self::File,

                crate::DirentType::Symlink => Self::Symlink,

                crate::DirentType::Service => Self::Service,

                crate::DirentType::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExtendedAttributeIteratorGetNextResponse>
        for ::fidl_fuchsia_io::ExtendedAttributeIteratorGetNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireExtendedAttributeIteratorGetNextResponse) -> Self {
            Self {
                attributes: ::fidl_next::TakeFrom::take_from(&from.attributes),

                last: ::fidl_next::TakeFrom::take_from(&from.last),
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `ExtendedAttributeIterator`
    /// protocol.
    pub type ExtendedAttributeIteratorProxy = ::fidl_next::ClientSender<
        ::fidl_next::fuchsia::zx::Channel,
        crate::ExtendedAttributeIterator,
    >;

    impl ::fidl_next::TakeFrom<crate::ExtendedAttributeIterator>
        for ::fidl_fuchsia_io::ExtendedAttributeIteratorMarker
    {
        #[inline]
        fn take_from(from: &crate::ExtendedAttributeIterator) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireReadableReadRequest>
        for ::fidl_fuchsia_io::ReadableReadRequest
    {
        #[inline]
        fn take_from(from: &crate::WireReadableReadRequest) -> Self {
            Self { count: ::fidl_next::TakeFrom::take_from(&from.count) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireReadableReadResponse>
        for ::fidl_fuchsia_io::ReadableReadResponse
    {
        #[inline]
        fn take_from(from: &crate::WireReadableReadResponse) -> Self {
            Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Readable`
    /// protocol.
    pub type ReadableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Readable>;

    impl ::fidl_next::TakeFrom<crate::Readable> for ::fidl_fuchsia_io::ReadableMarker {
        #[inline]
        fn take_from(from: &crate::Readable) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireWritableWriteRequest>
        for ::fidl_fuchsia_io::WritableWriteRequest
    {
        #[inline]
        fn take_from(from: &crate::WireWritableWriteRequest) -> Self {
            Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireWritableWriteResponse>
        for ::fidl_fuchsia_io::WritableWriteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireWritableWriteResponse) -> Self {
            Self { actual_count: ::fidl_next::TakeFrom::take_from(&from.actual_count) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Writable`
    /// protocol.
    pub type WritableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Writable>;

    impl ::fidl_next::TakeFrom<crate::Writable> for ::fidl_fuchsia_io::WritableMarker {
        #[inline]
        fn take_from(from: &crate::Writable) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileSeekRequest> for ::fidl_fuchsia_io::FileSeekRequest {
        #[inline]
        fn take_from(from: &crate::WireFileSeekRequest) -> Self {
            Self {
                origin: ::fidl_next::TakeFrom::take_from(&from.origin),

                offset: ::fidl_next::TakeFrom::take_from(&from.offset),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileSeekResponse> for ::fidl_fuchsia_io::FileSeekResponse {
        #[inline]
        fn take_from(from: &crate::WireFileSeekResponse) -> Self {
            Self { offset_from_start: ::fidl_next::TakeFrom::take_from(&from.offset_from_start) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileReadAtRequest> for ::fidl_fuchsia_io::FileReadAtRequest {
        #[inline]
        fn take_from(from: &crate::WireFileReadAtRequest) -> Self {
            Self {
                count: ::fidl_next::TakeFrom::take_from(&from.count),

                offset: ::fidl_next::TakeFrom::take_from(&from.offset),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileReadAtResponse>
        for ::fidl_fuchsia_io::FileReadAtResponse
    {
        #[inline]
        fn take_from(from: &crate::WireFileReadAtResponse) -> Self {
            Self { data: ::fidl_next::TakeFrom::take_from(&from.data) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileWriteAtRequest>
        for ::fidl_fuchsia_io::FileWriteAtRequest
    {
        #[inline]
        fn take_from(from: &crate::WireFileWriteAtRequest) -> Self {
            Self {
                data: ::fidl_next::TakeFrom::take_from(&from.data),

                offset: ::fidl_next::TakeFrom::take_from(&from.offset),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileWriteAtResponse>
        for ::fidl_fuchsia_io::FileWriteAtResponse
    {
        #[inline]
        fn take_from(from: &crate::WireFileWriteAtResponse) -> Self {
            Self { actual_count: ::fidl_next::TakeFrom::take_from(&from.actual_count) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileResizeRequest> for ::fidl_fuchsia_io::FileResizeRequest {
        #[inline]
        fn take_from(from: &crate::WireFileResizeRequest) -> Self {
            Self { length: ::fidl_next::TakeFrom::take_from(&from.length) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireVmoFlags> for ::fidl_fuchsia_io::VmoFlags {
        #[inline]
        fn take_from(from: &crate::WireVmoFlags) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileGetBackingMemoryRequest>
        for ::fidl_fuchsia_io::FileGetBackingMemoryRequest
    {
        #[inline]
        fn take_from(from: &crate::WireFileGetBackingMemoryRequest) -> Self {
            Self { flags: ::fidl_next::TakeFrom::take_from(&from.flags) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileGetBackingMemoryResponse>
        for ::fidl_fuchsia_io::FileGetBackingMemoryResponse
    {
        #[inline]
        fn take_from(from: &crate::WireFileGetBackingMemoryResponse) -> Self {
            Self { vmo: ::fidl_next::TakeFrom::take_from(&from.vmo) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLinkableLinkIntoRequest>
        for ::fidl_fuchsia_io::LinkableLinkIntoRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLinkableLinkIntoRequest) -> Self {
            Self {
                dst_parent_token: ::fidl_next::TakeFrom::take_from(&from.dst_parent_token),

                dst: ::fidl_next::TakeFrom::take_from(&from.dst),
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Linkable`
    /// protocol.
    pub type LinkableProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Linkable>;

    impl ::fidl_next::TakeFrom<crate::Linkable> for ::fidl_fuchsia_io::LinkableMarker {
        #[inline]
        fn take_from(from: &crate::Linkable) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileAllocateRequest>
        for ::fidl_fuchsia_io::FileAllocateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireFileAllocateRequest) -> Self {
            Self {
                offset: ::fidl_next::TakeFrom::take_from(&from.offset),

                length: ::fidl_next::TakeFrom::take_from(&from.length),

                mode: ::fidl_next::TakeFrom::take_from(&from.mode),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileEnableVerityRequest>
        for ::fidl_fuchsia_io::FileEnableVerityRequest
    {
        #[inline]
        fn take_from(from: &crate::WireFileEnableVerityRequest) -> Self {
            Self { options: ::fidl_next::TakeFrom::take_from(&from.options) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `File`
    /// protocol.
    pub type FileProxy = ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::File>;

    impl ::fidl_next::TakeFrom<crate::File> for ::fidl_fuchsia_io::FileMarker {
        #[inline]
        fn take_from(from: &crate::File) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileObject> for ::fidl_fuchsia_io::FileObject {
        #[inline]
        fn take_from(from: &crate::WireFileObject) -> Self {
            Self {
                event: ::fidl_next::TakeFrom::take_from(&from.event),

                stream: ::fidl_next::TakeFrom::take_from(&from.stream),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFileSignal> for ::fidl_fuchsia_io::FileSignal {
        #[inline]
        fn take_from(from: &crate::WireFileSignal) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFilesystemInfo> for ::fidl_fuchsia_io::FilesystemInfo {
        #[inline]
        fn take_from(from: &crate::WireFilesystemInfo) -> Self {
            Self {
                total_bytes: ::fidl_next::TakeFrom::take_from(&from.total_bytes),

                used_bytes: ::fidl_next::TakeFrom::take_from(&from.used_bytes),

                total_nodes: ::fidl_next::TakeFrom::take_from(&from.total_nodes),

                used_nodes: ::fidl_next::TakeFrom::take_from(&from.used_nodes),

                free_shared_pool_bytes: ::fidl_next::TakeFrom::take_from(
                    &from.free_shared_pool_bytes,
                ),

                fs_id: ::fidl_next::TakeFrom::take_from(&from.fs_id),

                block_size: ::fidl_next::TakeFrom::take_from(&from.block_size),

                max_filename_size: ::fidl_next::TakeFrom::take_from(&from.max_filename_size),

                fs_type: ::fidl_next::TakeFrom::take_from(&from.fs_type),

                padding: ::fidl_next::TakeFrom::take_from(&from.padding),

                name: ::fidl_next::TakeFrom::take_from(&from.name),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireService> for ::fidl_fuchsia_io::Service {
        #[inline]
        fn take_from(from: &crate::WireService) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSymlinkObject> for ::fidl_fuchsia_io::SymlinkObject {
        #[inline]
        fn take_from(from: &crate::WireSymlinkObject) -> Self {
            Self { target: ::fidl_next::TakeFrom::take_from(&from.target) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeInfoDeprecated>
        for ::fidl_fuchsia_io::NodeInfoDeprecated
    {
        #[inline]
        fn take_from(from: &crate::WireNodeInfoDeprecated) -> Self {
            match from.as_ref() {
                crate::node_info_deprecated::Ref::Service(value) => {
                    Self::Service(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_info_deprecated::Ref::File(value) => {
                    Self::File(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_info_deprecated::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_info_deprecated::Ref::Symlink(value) => {
                    Self::Symlink(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalNodeInfoDeprecated>
        for Option<Box<::fidl_fuchsia_io::NodeInfoDeprecated>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalNodeInfoDeprecated) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Symlink`
    /// protocol.
    pub type SymlinkProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Symlink>;

    impl ::fidl_next::TakeFrom<crate::Symlink> for ::fidl_fuchsia_io::SymlinkMarker {
        #[inline]
        fn take_from(from: &crate::Symlink) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireWatchEvent> for ::fidl_fuchsia_io::WatchEvent {
        #[inline]
        fn take_from(from: &crate::WireWatchEvent) -> Self {
            match crate::WatchEvent::from(*from) {
                crate::WatchEvent::Deleted => Self::Deleted,

                crate::WatchEvent::Added => Self::Added,

                crate::WatchEvent::Removed => Self::Removed,

                crate::WatchEvent::Existing => Self::Existing,

                crate::WatchEvent::Idle => Self::Idle,
            }
        }
    }
}