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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Operations
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireOperations> for Operations {
    #[inline]
    fn from_wire(wire: WireOperations) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireOperations {
    type Decoded<'de> = Self;

    #[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;
}
impl ::std::convert::TryFrom<u32> for SeekOrigin {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::Start),
            1 => Ok(Self::Current),
            2 => Ok(Self::End),

            _ => Err(Self::Error::new(value.into())),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SeekOrigin
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SeekOrigin
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireSeekOrigin> for SeekOrigin {
    #[inline]
    fn from_wire(wire: WireSeekOrigin) -> Self {
        Self::from(wire)
    }
}

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

/// 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::Wire for WireSeekOrigin {
    type Decoded<'de> = Self;

    #[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(
        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(self.origin, encoder, origin)?;

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for AdvisoryLockRange
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.origin, encoder, origin)?;

        ::fidl_next::EncodeRef::encode_ref(&self.offset, encoder, offset)?;

        ::fidl_next::EncodeRef::encode_ref(&self.length, encoder, length)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for AdvisoryLockRange
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockRange: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for AdvisoryLockRange
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockRange: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireAdvisoryLockRange> for AdvisoryLockRange {
    #[inline]
    fn from_wire(wire: WireAdvisoryLockRange) -> Self {
        Self {
            origin: ::fidl_next::FromWire::from_wire(wire.origin),

            offset: ::fidl_next::FromWire::from_wire(wire.offset),

            length: ::fidl_next::FromWire::from_wire(wire.length),
        }
    }
}

impl ::fidl_next::FromWireRef<WireAdvisoryLockRange> for AdvisoryLockRange {
    #[inline]
    fn from_wire_ref(wire: &WireAdvisoryLockRange) -> Self {
        Self {
            origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),

            offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),

            length: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireAdvisoryLockRange {
    type Decoded<'de> = 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;
}
impl ::std::convert::TryFrom<u32> for AdvisoryLockType {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Read),
            2 => Ok(Self::Write),
            3 => Ok(Self::Unlock),

            _ => Err(Self::Error::new(value.into())),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for AdvisoryLockType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for AdvisoryLockType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireAdvisoryLockType> for AdvisoryLockType {
    #[inline]
    fn from_wire(wire: WireAdvisoryLockType) -> Self {
        Self::from(wire)
    }
}

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

/// 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::Wire for WireAdvisoryLockType {
    type Decoded<'de> = Self;

    #[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, Default)]
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.wait.is_some() {
            return 3;
        }

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

        if self.type_.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for AdvisoryLockRequest {
    type Encoded = WireAdvisoryLockRequest<'static>;
}

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::Wire::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) = self.wait.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            wait,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

                1 => {
                    if let Some(type_) = self.type_.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for AdvisoryLockRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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_) = &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<'de> ::fidl_next::FromWire<WireAdvisoryLockRequest<'de>> for AdvisoryLockRequest {
    #[inline]
    fn from_wire(wire: WireAdvisoryLockRequest<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let type_ = wire.table.get(1);

        let range = wire.table.get(2);

        let wait = wire.table.get(3);

        Self {
            type_: type_.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAdvisoryLockType>()
                })
            }),

            range: range.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAdvisoryLockRange>()
                })
            }),

            wait: wait.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireAdvisoryLockRequest<'de>> for AdvisoryLockRequest {
    #[inline]
    fn from_wire_ref(wire: &WireAdvisoryLockRequest<'de>) -> Self {
        Self {
            type_: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAdvisoryLockType>()
                })
            }),

            range: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAdvisoryLockRange>()
                })
            }),

            wait: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<bool>()
                })
            }),
        }
    }
}

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

impl<'de> Drop for WireAdvisoryLockRequest<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAdvisoryLockType>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAdvisoryLockRange>() });

        let _ = self.table.get(3).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
    }
}

unsafe impl ::fidl_next::Wire for WireAdvisoryLockRequest<'static> {
    type Decoded<'de> = WireAdvisoryLockRequest<'de>;

    #[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<'static>
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<'de> WireAdvisoryLockRequest<'de> {
    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<'de> ::core::fmt::Debug for WireAdvisoryLockRequest<'de> {
    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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.request, encoder, request)?;

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.request, encoder, request)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for AdvisoryLockingAdvisoryLockRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockingAdvisoryLockRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for AdvisoryLockingAdvisoryLockRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    AdvisoryLockingAdvisoryLockRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireAdvisoryLockingAdvisoryLockRequest<'de>>
    for AdvisoryLockingAdvisoryLockRequest
{
    #[inline]
    fn from_wire(wire: WireAdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
        Self { request: ::fidl_next::FromWire::from_wire(wire.request) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireAdvisoryLockingAdvisoryLockRequest<'de>>
    for AdvisoryLockingAdvisoryLockRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireAdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
        Self { request: ::fidl_next::FromWireRef::from_wire_ref(&wire.request) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireAdvisoryLockingAdvisoryLockRequest<'static> {
    type Decoded<'de> = WireAdvisoryLockingAdvisoryLockRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAdvisoryLockingAdvisoryLockRequest<'static>
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,
            AdvisoryLockingServerHandler,
        };

        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<'static>;

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

    mod ___detail {

        pub struct AdvisoryLock<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for AdvisoryLock<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            type Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::AdvisoryLocking
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = AdvisoryLockingClientSender<___T>;
            type ServerSender = AdvisoryLockingServerSender<___T>;
        }

        /// The client sender for the `AdvisoryLocking` protocol.
        pub struct AdvisoryLockingClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> AdvisoryLockingClientSender<___T>
        where
            ___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"]
            pub fn advisory_lock(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockRequest<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.advisory_lock_with(AdvisoryLock { request })
            }

            #[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"]
            pub fn advisory_lock_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(7992130864415541162, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `AdvisoryLocking` protocol.
        #[repr(transparent)]
        pub struct AdvisoryLockingServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> AdvisoryLockingServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

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

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

/// 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<AdvisoryLocking, ___T>,

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

        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

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

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

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.advisory_lock(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for AllocateMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireAllocateMode> for AllocateMode {
    #[inline]
    fn from_wire(wire: WireAllocateMode) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireAllocateMode {
    type Decoded<'de> = Self;

    #[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, Default)]
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<'static>;
}

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::Wire::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) = self.rights.take() {
                        ::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<'de> ::fidl_next::FromWire<WireConnectionInfo<'de>> for ConnectionInfo {
    #[inline]
    fn from_wire(wire: WireConnectionInfo<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let rights = wire.table.get(1);

        Self {
            rights: rights.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireOperations>()
                })
            }),
        }
    }
}

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

impl<'de> Drop for WireConnectionInfo<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireOperations>() });
    }
}

unsafe impl ::fidl_next::Wire for WireConnectionInfo<'static> {
    type Decoded<'de> = WireConnectionInfo<'de>;

    #[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<'static>
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<'de> WireConnectionInfo<'de> {
    pub fn rights(&self) -> Option<&crate::WireOperations> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireConnectionInfo<'de> {
    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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OpenFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireOpenFlags> for OpenFlags {
    #[inline]
    fn from_wire(wire: WireOpenFlags) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireOpenFlags {
    type Decoded<'de> = Self;

    #[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(
        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(self.mode, encoder, mode)?;

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

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

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

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeAttributes
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.mode, encoder, mode)?;

        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder, id)?;

        ::fidl_next::EncodeRef::encode_ref(&self.content_size, encoder, content_size)?;

        ::fidl_next::EncodeRef::encode_ref(&self.storage_size, encoder, storage_size)?;

        ::fidl_next::EncodeRef::encode_ref(&self.link_count, encoder, link_count)?;

        ::fidl_next::EncodeRef::encode_ref(&self.creation_time, encoder, creation_time)?;

        ::fidl_next::EncodeRef::encode_ref(&self.modification_time, encoder, modification_time)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeAttributes> for NodeAttributes {
    #[inline]
    fn from_wire(wire: WireNodeAttributes) -> Self {
        Self {
            mode: ::fidl_next::FromWire::from_wire(wire.mode),

            id: ::fidl_next::FromWire::from_wire(wire.id),

            content_size: ::fidl_next::FromWire::from_wire(wire.content_size),

            storage_size: ::fidl_next::FromWire::from_wire(wire.storage_size),

            link_count: ::fidl_next::FromWire::from_wire(wire.link_count),

            creation_time: ::fidl_next::FromWire::from_wire(wire.creation_time),

            modification_time: ::fidl_next::FromWire::from_wire(wire.modification_time),
        }
    }
}

impl ::fidl_next::FromWireRef<WireNodeAttributes> for NodeAttributes {
    #[inline]
    fn from_wire_ref(wire: &WireNodeAttributes) -> Self {
        Self {
            mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),

            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),

            content_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.content_size),

            storage_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.storage_size),

            link_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.link_count),

            creation_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.creation_time),

            modification_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireNodeAttributes {
    type Decoded<'de> = 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(())
    }
}

::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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeAttributeFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireNodeAttributeFlags> for NodeAttributeFlags {
    #[inline]
    fn from_wire(wire: WireNodeAttributeFlags) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireNodeAttributeFlags {
    type Decoded<'de> = Self;

    #[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 NodeQueryFilesystemResponse {
    pub s: i32,

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

impl ::fidl_next::Encodable for NodeQueryFilesystemResponse {
    type Encoded = WireNodeQueryFilesystemResponse<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        ::fidl_next::EncodeRef::encode_ref(&self.info, encoder, info)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeQueryFilesystemResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeQueryFilesystemResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeQueryFilesystemResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeQueryFilesystemResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireNodeQueryFilesystemResponse<'de>>
    for NodeQueryFilesystemResponse
{
    #[inline]
    fn from_wire(wire: WireNodeQueryFilesystemResponse<'de>) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            info: ::fidl_next::FromWire::from_wire(wire.info),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeQueryFilesystemResponse<'de>>
    for NodeQueryFilesystemResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeQueryFilesystemResponse<'de>) -> Self {
        Self {
            s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),

            info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info),
        }
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireNodeQueryFilesystemResponse<'static> {
    type Decoded<'de> = WireNodeQueryFilesystemResponse<'de>;

    #[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<'static>
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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ModeType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireModeType> for ModeType {
    #[inline]
    fn from_wire(wire: WireModeType) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireModeType {
    type Decoded<'de> = Self;

    #[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<'de> = ::fidl_next::WireString<'de>;

#[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, WireDirectoryReadDirentsRequest> = 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(
        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(self.max_bytes, encoder, max_bytes)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryReadDirentsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.max_bytes, encoder, max_bytes)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryReadDirentsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryReadDirentsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireDirectoryReadDirentsRequest> for DirectoryReadDirentsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryReadDirentsRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryReadDirentsRequest) -> Self {
        Self { max_bytes: ::fidl_next::FromWire::from_wire(wire.max_bytes) }
    }
}

impl ::fidl_next::FromWireRef<WireDirectoryReadDirentsRequest> for DirectoryReadDirentsRequest {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryReadDirentsRequest) -> Self {
        Self { max_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireDirectoryReadDirentsRequest {
    type Decoded<'de> = 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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        ::fidl_next::EncodeRef::encode_ref(&self.dirents, encoder, dirents)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryReadDirentsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryReadDirentsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryReadDirentsResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireDirectoryReadDirentsResponse<'de>>
    for DirectoryReadDirentsResponse
{
    #[inline]
    fn from_wire(wire: WireDirectoryReadDirentsResponse<'de>) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            dirents: ::fidl_next::FromWire::from_wire(wire.dirents),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireDirectoryReadDirentsResponse<'de>>
    for DirectoryReadDirentsResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryReadDirentsResponse<'de>) -> Self {
        Self {
            s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),

            dirents: ::fidl_next::FromWireRef::from_wire_ref(&wire.dirents),
        }
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireDirectoryReadDirentsResponse<'static> {
    type Decoded<'de> = WireDirectoryReadDirentsResponse<'de>;

    #[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<'static>
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, WireDirectoryRewindResponse> = 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(
        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(self.s, encoder, s)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryRewindResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRewindResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryRewindResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryRewindResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryRewindResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireDirectoryRewindResponse> for DirectoryRewindResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryRewindResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryRewindResponse) -> Self {
        Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
    }
}

impl ::fidl_next::FromWireRef<WireDirectoryRewindResponse> for DirectoryRewindResponse {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryRewindResponse) -> Self {
        Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireDirectoryRewindResponse {
    type Decoded<'de> = 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, WireDirectoryGetTokenResponse> = 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(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryGetTokenResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryGetTokenResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireDirectoryGetTokenResponse> for DirectoryGetTokenResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryGetTokenResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled()
                && <Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::FromWire<
                    ::fidl_next::fuchsia::WireOptionalHandle,
                >>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryGetTokenResponse) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            token: ::fidl_next::FromWire::from_wire(wire.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::Wire for WireDirectoryGetTokenResponse {
    type Decoded<'de> = 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<'de> = ::fidl_next::WireString<'de>;

#[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<'static>;
}

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(
        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(self.src, encoder, src)?;

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryLinkRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryLinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireDirectoryLinkRequest<'de>> for DirectoryLinkRequest {
    #[inline]
    fn from_wire(wire: WireDirectoryLinkRequest<'de>) -> Self {
        Self {
            src: ::fidl_next::FromWire::from_wire(wire.src),

            dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),

            dst: ::fidl_next::FromWire::from_wire(wire.dst),
        }
    }
}

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

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

    pub dst: ::fidl_next::WireString<'de>,
}

unsafe impl ::fidl_next::Wire for WireDirectoryLinkRequest<'static> {
    type Decoded<'de> = WireDirectoryLinkRequest<'de>;

    #[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<'static>
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, WireDirectoryLinkResponse> = 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(
        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(self.s, encoder, s)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryLinkResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryLinkResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryLinkResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryLinkResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryLinkResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireDirectoryLinkResponse> for DirectoryLinkResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryLinkResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryLinkResponse) -> Self {
        Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
    }
}

impl ::fidl_next::FromWireRef<WireDirectoryLinkResponse> for DirectoryLinkResponse {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryLinkResponse) -> Self {
        Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireDirectoryLinkResponse {
    type Decoded<'de> = 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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UnlinkFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireUnlinkFlags> for UnlinkFlags {
    #[inline]
    fn from_wire(wire: WireUnlinkFlags) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireUnlinkFlags {
    type Decoded<'de> = Self;

    #[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, Default)]
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<'static>;
}

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::Wire::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) = self.flags.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UnlinkOptions
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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<'de> ::fidl_next::FromWire<WireUnlinkOptions<'de>> for UnlinkOptions {
    #[inline]
    fn from_wire(wire: WireUnlinkOptions<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let flags = wire.table.get(1);

        Self {
            flags: flags.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireUnlinkFlags>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUnlinkOptions<'de>> for UnlinkOptions {
    #[inline]
    fn from_wire_ref(wire: &WireUnlinkOptions<'de>) -> Self {
        Self {
            flags: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireUnlinkFlags>()
                })
            }),
        }
    }
}

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

impl<'de> Drop for WireUnlinkOptions<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireUnlinkFlags>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUnlinkOptions<'static> {
    type Decoded<'de> = WireUnlinkOptions<'de>;

    #[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<'static>
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<'de> WireUnlinkOptions<'de> {
    pub fn flags(&self) -> Option<&crate::WireUnlinkFlags> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUnlinkOptions<'de> {
    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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.name, encoder, name)?;

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

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.name, encoder, name)?;

        ::fidl_next::EncodeRef::encode_ref(&self.options, encoder, options)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryUnlinkRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryUnlinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryUnlinkRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryUnlinkRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireDirectoryUnlinkRequest<'de>> for DirectoryUnlinkRequest {
    #[inline]
    fn from_wire(wire: WireDirectoryUnlinkRequest<'de>) -> Self {
        Self {
            name: ::fidl_next::FromWire::from_wire(wire.name),

            options: ::fidl_next::FromWire::from_wire(wire.options),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireDirectoryUnlinkRequest<'de>> for DirectoryUnlinkRequest {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryUnlinkRequest<'de>) -> Self {
        Self {
            name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),

            options: ::fidl_next::FromWireRef::from_wire_ref(&wire.options),
        }
    }
}

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

    pub options: crate::WireUnlinkOptions<'de>,
}

unsafe impl ::fidl_next::Wire for WireDirectoryUnlinkRequest<'static> {
    type Decoded<'de> = WireDirectoryUnlinkRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryUnlinkRequest<'static>
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<'static>;
}

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(
        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(self.src, encoder, src)?;

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRenameRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryRenameRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireDirectoryRenameRequest<'de>> for DirectoryRenameRequest {
    #[inline]
    fn from_wire(wire: WireDirectoryRenameRequest<'de>) -> Self {
        Self {
            src: ::fidl_next::FromWire::from_wire(wire.src),

            dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),

            dst: ::fidl_next::FromWire::from_wire(wire.dst),
        }
    }
}

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

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

    pub dst: ::fidl_next::WireString<'de>,
}

unsafe impl ::fidl_next::Wire for WireDirectoryRenameRequest<'static> {
    type Decoded<'de> = WireDirectoryRenameRequest<'de>;

    #[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<'static>
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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WatchMask
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireWatchMask> for WatchMask {
    #[inline]
    fn from_wire(wire: WireWatchMask) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireWatchMask {
    type Decoded<'de> = Self;

    #[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<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel>,
}

impl ::fidl_next::Encodable for DirectoryWatchRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirectoryWatchRequest> = 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<
                    crate::DirectoryWatcher,
                    ::fidl_next::fuchsia::zx::Channel,
                > 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(
        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(self.mask, encoder, mask)?;

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryWatchRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryWatchRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireDirectoryWatchRequest> for DirectoryWatchRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryWatchRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    crate::WatchMask as ::fidl_next::FromWire<crate::WireWatchMask>
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    u32 as ::fidl_next::FromWire<::fidl_next::WireU32>
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::FromWire<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::WireChannel>>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryWatchRequest) -> Self {
        Self {
            mask: ::fidl_next::FromWire::from_wire(wire.mask),

            options: ::fidl_next::FromWire::from_wire(wire.options),

            watcher: ::fidl_next::FromWire::from_wire(wire.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<crate::DirectoryWatcher, ::fidl_next::fuchsia::WireChannel>,
}

unsafe impl ::fidl_next::Wire for WireDirectoryWatchRequest {
    type Decoded<'de> = 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, WireDirectoryWatchResponse> = 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(
        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(self.s, encoder, s)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryWatchResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryWatchResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryWatchResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryWatchResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryWatchResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireDirectoryWatchResponse> for DirectoryWatchResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryWatchResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireDirectoryWatchResponse) -> Self {
        Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
    }
}

impl ::fidl_next::FromWireRef<WireDirectoryWatchResponse> for DirectoryWatchResponse {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryWatchResponse) -> Self {
        Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireDirectoryWatchResponse {
    type Decoded<'de> = 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<'static>;
}

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(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeOnOpenRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeOnOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireNodeOnOpenRequest<'de>> for NodeOnOpenRequest {
    #[inline]
    fn from_wire(wire: WireNodeOnOpenRequest<'de>) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            info: ::fidl_next::FromWire::from_wire(wire.info),
        }
    }
}

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

    pub info: crate::WireOptionalNodeInfoDeprecated<'de>,
}

unsafe impl ::fidl_next::Wire for WireNodeOnOpenRequest<'static> {
    type Decoded<'de> = WireNodeOnOpenRequest<'de>;

    #[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<'static>
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<'de> = ::fidl_next::WireVector<'de, u8>;

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

impl ::fidl_next::Encodable for NodeListExtendedAttributesRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        Self,
        WireNodeListExtendedAttributesRequest,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                crate::ExtendedAttributeIterator,
                ::fidl_next::fuchsia::zx::Channel,
            > 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(
        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(self.iterator, encoder, iterator)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeListExtendedAttributesRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeListExtendedAttributesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireNodeListExtendedAttributesRequest>
    for NodeListExtendedAttributesRequest
{
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireNodeListExtendedAttributesRequest,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                crate::ExtendedAttributeIterator,
                ::fidl_next::fuchsia::zx::Channel,
            > as ::fidl_next::FromWire<
                ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeListExtendedAttributesRequest) -> Self {
        Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeListExtendedAttributesRequest {
    type Decoded<'de> = 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<'de> = ::fidl_next::WireVector<'de, u8>;

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

impl ::fidl_next::Encodable for NodeGetExtendedAttributeRequest {
    type Encoded = WireNodeGetExtendedAttributeRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.name, encoder, name)?;

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.name, encoder, name)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeGetExtendedAttributeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeGetExtendedAttributeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetExtendedAttributeRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireNodeGetExtendedAttributeRequest<'de>>
    for NodeGetExtendedAttributeRequest
{
    #[inline]
    fn from_wire(wire: WireNodeGetExtendedAttributeRequest<'de>) -> Self {
        Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeGetExtendedAttributeRequest<'de>>
    for NodeGetExtendedAttributeRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeGetExtendedAttributeRequest<'de>) -> Self {
        Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeGetExtendedAttributeRequest<'static> {
    type Decoded<'de> = WireNodeGetExtendedAttributeRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeGetExtendedAttributeRequest<'static>
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<'static>;
}

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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExtendedAttributeValue { raw, _phantom: _ } = 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 ExtendedAttributeValue {
    type EncodedOption = WireOptionalExtendedAttributeValue<'static>;
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireExtendedAttributeValue<'de>> for ExtendedAttributeValue {
    #[inline]
    fn from_wire(wire: WireExtendedAttributeValue<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
            })),

            2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalExtendedAttributeValue<'de>>
    for Box<ExtendedAttributeValue>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalExtendedAttributeValue<'de>) -> Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(Box::new(::fidl_next::FromWire::from_wire(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`ExtendedAttributeValue`].
#[repr(transparent)]
pub struct WireExtendedAttributeValue<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireExtendedAttributeValue<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>() };
            }

            2 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireExtendedAttributeValue<'static> {
    type Decoded<'de> = WireExtendedAttributeValue<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

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

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireExtendedAttributeValue<'de> {
    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<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, 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<'de> ::core::fmt::Debug for WireExtendedAttributeValue<'de> {
    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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalExtendedAttributeValue<'static> {
    type Decoded<'de> = WireOptionalExtendedAttributeValue<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalExtendedAttributeValue<'de> {
    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<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireExtendedAttributeValue<'de>> {
        if self.is_some() {
            Some(WireExtendedAttributeValue {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalExtendedAttributeValue<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, 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<'de> ::core::fmt::Debug for WireOptionalExtendedAttributeValue<'de> {
    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;
}
impl ::std::convert::TryFrom<u32> for SetExtendedAttributeMode {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Set),
            2 => Ok(Self::Create),
            3 => Ok(Self::Replace),

            _ => Err(Self::Error::new(value.into())),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SetExtendedAttributeMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SetExtendedAttributeMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireSetExtendedAttributeMode> for SetExtendedAttributeMode {
    #[inline]
    fn from_wire(wire: WireSetExtendedAttributeMode) -> Self {
        Self::from(wire)
    }
}

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

/// 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::Wire for WireSetExtendedAttributeMode {
    type Decoded<'de> = Self;

    #[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<'static>;
}

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(
        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(self.name, encoder, name)?;

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeSetExtendedAttributeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireNodeSetExtendedAttributeRequest<'de>>
    for NodeSetExtendedAttributeRequest
{
    #[inline]
    fn from_wire(wire: WireNodeSetExtendedAttributeRequest<'de>) -> Self {
        Self {
            name: ::fidl_next::FromWire::from_wire(wire.name),

            value: ::fidl_next::FromWire::from_wire(wire.value),

            mode: ::fidl_next::FromWire::from_wire(wire.mode),
        }
    }
}

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

    pub value: crate::WireExtendedAttributeValue<'de>,

    pub mode: crate::WireSetExtendedAttributeMode,
}

unsafe impl ::fidl_next::Wire for WireNodeSetExtendedAttributeRequest<'static> {
    type Decoded<'de> = WireNodeSetExtendedAttributeRequest<'de>;

    #[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<'static>
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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.name, encoder, name)?;

        Ok(())
    }
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.name, encoder, name)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeRemoveExtendedAttributeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeRemoveExtendedAttributeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeRemoveExtendedAttributeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeRemoveExtendedAttributeRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireNodeRemoveExtendedAttributeRequest<'de>>
    for NodeRemoveExtendedAttributeRequest
{
    #[inline]
    fn from_wire(wire: WireNodeRemoveExtendedAttributeRequest<'de>) -> Self {
        Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeRemoveExtendedAttributeRequest<'de>>
    for NodeRemoveExtendedAttributeRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeRemoveExtendedAttributeRequest<'de>) -> Self {
        Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeRemoveExtendedAttributeRequest<'static> {
    type Decoded<'de> = WireNodeRemoveExtendedAttributeRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeRemoveExtendedAttributeRequest<'static>
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<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
}

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

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

                && <
                    ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel> 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(
        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(self.flags, encoder, flags)?;

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedCloneRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedCloneRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireNodeDeprecatedCloneRequest> for NodeDeprecatedCloneRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireNodeDeprecatedCloneRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

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

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

        )
    };

    #[inline]
    fn from_wire(wire: WireNodeDeprecatedCloneRequest) -> Self {
        Self {
            flags: ::fidl_next::FromWire::from_wire(wire.flags),

            object: ::fidl_next::FromWire::from_wire(wire.object),
        }
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedCloneRequest {
    type Decoded<'de> = 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)]
pub struct NodeDeprecatedGetAttrResponse {
    pub s: i32,

    pub attributes: crate::NodeAttributes,
}

impl ::fidl_next::Encodable for NodeDeprecatedGetAttrResponse {
    type Encoded = WireNodeDeprecatedGetAttrResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedGetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedGetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        ::fidl_next::EncodeRef::encode_ref(&self.attributes, encoder, attributes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeDeprecatedGetAttrResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeDeprecatedGetAttrResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedGetAttrResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedGetAttrResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedGetAttrResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedGetAttrResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedGetAttrResponse> for NodeDeprecatedGetAttrResponse {
    #[inline]
    fn from_wire(wire: WireNodeDeprecatedGetAttrResponse) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
        }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedGetAttrResponse> for NodeDeprecatedGetAttrResponse {
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedGetAttrResponse) -> Self {
        Self {
            s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),

            attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
        }
    }
}

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

    pub attributes: crate::WireNodeAttributes,
}

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedGetAttrResponse {
    type Decoded<'de> = WireNodeDeprecatedGetAttrResponse;

    #[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 WireNodeDeprecatedGetAttrResponse
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(())
    }
}

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

    pub attributes: crate::NodeAttributes,
}

impl ::fidl_next::Encodable for NodeDeprecatedSetAttrRequest {
    type Encoded = WireNodeDeprecatedSetAttrRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedSetAttrRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        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(self.flags, encoder, flags)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedSetAttrRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        ::fidl_next::EncodeRef::encode_ref(&self.attributes, encoder, attributes)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeDeprecatedSetAttrRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeDeprecatedSetAttrRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedSetAttrRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetAttrRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedSetAttrRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetAttrRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedSetAttrRequest> for NodeDeprecatedSetAttrRequest {
    #[inline]
    fn from_wire(wire: WireNodeDeprecatedSetAttrRequest) -> Self {
        Self {
            flags: ::fidl_next::FromWire::from_wire(wire.flags),

            attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
        }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedSetAttrRequest> for NodeDeprecatedSetAttrRequest {
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedSetAttrRequest) -> Self {
        Self {
            flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),

            attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
        }
    }
}

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

    pub attributes: crate::WireNodeAttributes,
}

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedSetAttrRequest {
    type Decoded<'de> = WireNodeDeprecatedSetAttrRequest;

    #[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 WireNodeDeprecatedSetAttrRequest
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 NodeDeprecatedSetAttrResponse {
    pub s: i32,
}

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

    type Encoded = WireNodeDeprecatedSetAttrResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeDeprecatedSetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        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(self.s, encoder, s)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedSetAttrResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeDeprecatedSetAttrResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeDeprecatedSetAttrResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedSetAttrResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetAttrResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedSetAttrResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetAttrResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedSetAttrResponse> for NodeDeprecatedSetAttrResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireNodeDeprecatedSetAttrResponse,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeDeprecatedSetAttrResponse) -> Self {
        Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedSetAttrResponse> for NodeDeprecatedSetAttrResponse {
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedSetAttrResponse) -> Self {
        Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedSetAttrResponse {
    type Decoded<'de> = WireNodeDeprecatedSetAttrResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeDeprecatedSetAttrResponse
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)]
#[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,
        WireNodeDeprecatedGetFlagsResponse,
    > = 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(
        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(self.s, encoder, s)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedGetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        ::fidl_next::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedGetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedGetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedGetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedGetFlagsResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedGetFlagsResponse> for NodeDeprecatedGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireNodeDeprecatedGetFlagsResponse,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

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

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

        )
    };

    #[inline]
    fn from_wire(wire: WireNodeDeprecatedGetFlagsResponse) -> Self {
        Self {
            s: ::fidl_next::FromWire::from_wire(wire.s),

            flags: ::fidl_next::FromWire::from_wire(wire.flags),
        }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedGetFlagsResponse>
    for NodeDeprecatedGetFlagsResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedGetFlagsResponse) -> Self {
        Self {
            s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),

            flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireNodeDeprecatedGetFlagsResponse {
    type Decoded<'de> = 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,
        WireNodeDeprecatedSetFlagsRequest,
    > = 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(
        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(self.flags, encoder, flags)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedSetFlagsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedSetFlagsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedSetFlagsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedSetFlagsRequest> for NodeDeprecatedSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireNodeDeprecatedSetFlagsRequest,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

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

        )
    };

    #[inline]
    fn from_wire(wire: WireNodeDeprecatedSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedSetFlagsRequest> for NodeDeprecatedSetFlagsRequest {
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedSetFlagsRequest {
    type Decoded<'de> = 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,
        WireNodeDeprecatedSetFlagsResponse,
    > = 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(
        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(self.s, encoder, s)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeDeprecatedSetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.s, encoder, s)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeDeprecatedSetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeDeprecatedSetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeDeprecatedSetFlagsResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeDeprecatedSetFlagsResponse> for NodeDeprecatedSetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireNodeDeprecatedSetFlagsResponse,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeDeprecatedSetFlagsResponse) -> Self {
        Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeDeprecatedSetFlagsResponse>
    for NodeDeprecatedSetFlagsResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeDeprecatedSetFlagsResponse) -> Self {
        Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeDeprecatedSetFlagsResponse {
    type Decoded<'de> = 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_BYTES`]).\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_BYTES = 2;
        #[doc = " Write byte contents to a file.\n"]const PERM_WRITE_BYTES = 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_UPDATE_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\n PERM_ENUMERATE otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PERM_MODIFY_DIRECTORY = 256;
        #[doc = " Inherit write permissions when available (PERM_WRITE_BYTES, PERM_UPDATE_ATTRIBUTES,\n PERM_MODIFY_DIRECTORY, /// PERM_ENUMERATE). Servers must ensure this flag is removed\n if the parent connection lacks any of these rights. See [`INHERITED_WRITE_PERMISSIONS`]\n for the exact set of permissions that 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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Flags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireFlags> for Flags {
    #[inline]
    fn from_wire(wire: WireFlags) -> Self {
        Self::from(wire)
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireFlags {
    type Decoded<'de> = Self;

    #[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, WireNodeGetFlagsResponse> = 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(
        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(self.flags, encoder, flags)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeGetFlagsResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeGetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetFlagsResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeGetFlagsResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetFlagsResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeGetFlagsResponse> for NodeGetFlagsResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireNodeGetFlagsResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::FromWire<crate::WireFlags>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeGetFlagsResponse) -> Self {
        Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeGetFlagsResponse> for NodeGetFlagsResponse {
    #[inline]
    fn from_wire_ref(wire: &WireNodeGetFlagsResponse) -> Self {
        Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeGetFlagsResponse {
    type Decoded<'de> = 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, WireNodeSetFlagsRequest> = 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(
        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(self.flags, encoder, flags)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeSetFlagsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeSetFlagsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetFlagsRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeSetFlagsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeSetFlagsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeSetFlagsRequest> for NodeSetFlagsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireNodeSetFlagsRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::Flags as ::fidl_next::FromWire<crate::WireFlags>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeSetFlagsRequest> for NodeSetFlagsRequest {
    #[inline]
    fn from_wire_ref(wire: &WireNodeSetFlagsRequest) -> Self {
        Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeSetFlagsRequest {
    type Decoded<'de> = 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, WireEmptyStruct> =
        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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for EmptyStruct
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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 EmptyStruct {
    type EncodedOption = ::fidl_next::WireBox<'static, WireEmptyStruct>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for EmptyStruct
where
    ___E: ::fidl_next::Encoder + ?Sized,
    EmptyStruct: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for EmptyStruct
where
    ___E: ::fidl_next::Encoder + ?Sized,
    EmptyStruct: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireEmptyStruct> for EmptyStruct {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireEmptyStruct, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn from_wire(wire: WireEmptyStruct) -> Self {
        Self {}
    }
}

impl ::fidl_next::FromWireRef<WireEmptyStruct> for EmptyStruct {
    #[inline]
    fn from_wire_ref(wire: &WireEmptyStruct) -> Self {
        Self {}
    }
}

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

unsafe impl ::fidl_next::Wire for WireEmptyStruct {
    type Decoded<'de> = 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<'static>;
}

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

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

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireSelinuxContext { raw, _phantom: _ } = 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 SelinuxContext {
    type EncodedOption = WireOptionalSelinuxContext<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireSelinuxContext<'de>> for SelinuxContext {
    #[inline]
    fn from_wire(wire: WireSelinuxContext<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
            })),

            2 => Self::UseExtendedAttributes(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireEmptyStruct>()
            })),

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

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

            2 => Self::UseExtendedAttributes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireEmptyStruct>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalSelinuxContext<'de>> for Box<SelinuxContext> {
    #[inline]
    fn from_wire_option(wire: WireOptionalSelinuxContext<'de>) -> Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(Box::new(::fidl_next::FromWire::from_wire(inner)))
        } else {
            None
        }
    }
}

impl<'de> ::fidl_next::FromWireOptionRef<WireOptionalSelinuxContext<'de>> for Box<SelinuxContext> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalSelinuxContext<'de>) -> Option<Self> {
        if let Some(inner) = wire.as_ref() {
            Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`SelinuxContext`].
#[repr(transparent)]
pub struct WireSelinuxContext<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireSelinuxContext<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>() };
            }

            2 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireEmptyStruct>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireSelinuxContext<'static> {
    type Decoded<'de> = WireSelinuxContext<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

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

        UseExtendedAttributes(&'de crate::WireEmptyStruct),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireSelinuxContext<'de> {
    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<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
                    raw, decoder,
                )?
            }

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireSelinuxContext<'de> {
    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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalSelinuxContext<'static> {
    type Decoded<'de> = WireOptionalSelinuxContext<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalSelinuxContext<'de> {
    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<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireSelinuxContext<'de>> {
        if self.is_some() {
            Some(WireSelinuxContext { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalSelinuxContext<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, 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<'de> ::core::fmt::Debug for WireOptionalSelinuxContext<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[derive(Clone, Debug, Default)]
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.wrapping_key_id.is_some() {
            return 10;
        }

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

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

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

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

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

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

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

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

        if self.creation_time.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for MutableNodeAttributes {
    type Encoded = WireMutableNodeAttributes<'static>;
}

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::Wire::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) = self.wrapping_key_id.take() {
                        ::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) = self.selinux_context.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            selinux_context,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

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

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

                2 => {
                    if let Some(modification_time) = self.modification_time.take() {
                        ::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) = self.creation_time.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for MutableNodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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<'de> ::fidl_next::FromWire<WireMutableNodeAttributes<'de>> for MutableNodeAttributes {
    #[inline]
    fn from_wire(wire: WireMutableNodeAttributes<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let creation_time = wire.table.get(1);

        let modification_time = wire.table.get(2);

        let mode = wire.table.get(3);

        let uid = wire.table.get(4);

        let gid = wire.table.get(5);

        let rdev = wire.table.get(6);

        let access_time = wire.table.get(7);

        let casefold = wire.table.get(8);

        let selinux_context = wire.table.get(9);

        let wrapping_key_id = wire.table.get(10);

        Self {
            creation_time: creation_time.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            modification_time: modification_time.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            mode: mode.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU32>()
                })
            }),

            uid: uid.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU32>()
                })
            }),

            gid: gid.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU32>()
                })
            }),

            rdev: rdev.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            access_time: access_time.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            casefold: casefold.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
            }),

            selinux_context: selinux_context.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireSelinuxContext<'de>>()
                })
            }),

            wrapping_key_id: wrapping_key_id.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<[u8; 16]>() })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireMutableNodeAttributes<'de>> for MutableNodeAttributes {
    #[inline]
    fn from_wire_ref(wire: &WireMutableNodeAttributes<'de>) -> Self {
        Self {
            creation_time: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            modification_time: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            mode: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU32>()
                })
            }),

            uid: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU32>()
                })
            }),

            gid: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU32>()
                })
            }),

            rdev: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            access_time: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            casefold: wire.table.get(8).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<bool>()
                })
            }),

            selinux_context: wire.table.get(9).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireSelinuxContext<'de>>()
                })
            }),

            wrapping_key_id: wire.table.get(10).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<[u8; 16]>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`MutableNodeAttributes`].
#[repr(C)]
pub struct WireMutableNodeAttributes<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireMutableNodeAttributes<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self.table.get(8).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });

        let _ = self
            .table
            .get(9)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireSelinuxContext<'de>>() });

        let _ = self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 16]>() });
    }
}

unsafe impl ::fidl_next::Wire for WireMutableNodeAttributes<'static> {
    type Decoded<'de> = WireMutableNodeAttributes<'de>;

    #[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<'static>
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<'static>>(
                        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<'de> WireMutableNodeAttributes<'de> {
    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<'de>> {
        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<'de> ::core::fmt::Debug for WireMutableNodeAttributes<'de> {
    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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeProtocolKinds
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireNodeProtocolKinds> for NodeProtocolKinds {
    #[inline]
    fn from_wire(wire: WireNodeProtocolKinds) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireNodeProtocolKinds> for NodeProtocolKinds {
    #[inline]
    fn from_wire_ref(wire: &WireNodeProtocolKinds) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeProtocolKinds {
    type Decoded<'de> = Self;

    #[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;
}
impl ::std::convert::From<u8> for HashAlgorithm {
    fn from(value: u8) -> Self {
        match value {
            1 => Self::Sha256,
            2 => Self::Sha512,

            _ => Self::UnknownOrdinal_(value),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for HashAlgorithm
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for HashAlgorithm
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireHashAlgorithm> for HashAlgorithm {
    #[inline]
    fn from_wire(wire: WireHashAlgorithm) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireHashAlgorithm> for HashAlgorithm {
    #[inline]
    fn from_wire_ref(wire: &WireHashAlgorithm) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireHashAlgorithm {
    type Decoded<'de> = Self;

    #[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, Default)]
pub struct VerificationOptions {
    pub hash_algorithm: Option<crate::HashAlgorithm>,

    pub salt: Option<Vec<u8>>,
}

impl VerificationOptions {
    fn __max_ordinal(&self) -> usize {
        if self.salt.is_some() {
            return 2;
        }

        if self.hash_algorithm.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for VerificationOptions {
    type Encoded = WireVerificationOptions<'static>;
}

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::Wire::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) = self.salt.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            salt,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(hash_algorithm) = self.hash_algorithm.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for VerificationOptions
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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<'de> ::fidl_next::FromWire<WireVerificationOptions<'de>> for VerificationOptions {
    #[inline]
    fn from_wire(wire: WireVerificationOptions<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let hash_algorithm = wire.table.get(1);

        let salt = wire.table.get(2);

        Self {
            hash_algorithm: hash_algorithm.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireHashAlgorithm>()
                })
            }),

            salt: salt.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireVerificationOptions<'de>> for VerificationOptions {
    #[inline]
    fn from_wire_ref(wire: &WireVerificationOptions<'de>) -> Self {
        Self {
            hash_algorithm: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireHashAlgorithm>()
                })
            }),

            salt: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`VerificationOptions`].
#[repr(C)]
pub struct WireVerificationOptions<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireVerificationOptions<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireHashAlgorithm>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireVerificationOptions<'static> {
    type Decoded<'de> = WireVerificationOptions<'de>;

    #[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<'static>
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<'static, 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<'de> WireVerificationOptions<'de> {
    pub fn hash_algorithm(&self) -> Option<&crate::WireHashAlgorithm> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn salt(&self) -> Option<&::fidl_next::WireVector<'de, u8>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireVerificationOptions<'de> {
    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, Default)]
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.verity_enabled.is_some() {
            return 10;
        }

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

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

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

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

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

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

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

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

        if self.protocols.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ImmutableNodeAttributes {
    type Encoded = WireImmutableNodeAttributes<'static>;
}

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::Wire::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) = self.verity_enabled.take() {
                        ::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) = self.root_hash.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            root_hash,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

                5 => {
                    if let Some(link_count) = self.link_count.take() {
                        ::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) = self.storage_size.take() {
                        ::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) = self.content_size.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            content_size,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

                1 => {
                    if let Some(protocols) = self.protocols.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ImmutableNodeAttributes
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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) = &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<'de> ::fidl_next::FromWire<WireImmutableNodeAttributes<'de>> for ImmutableNodeAttributes {
    #[inline]
    fn from_wire(wire: WireImmutableNodeAttributes<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let protocols = wire.table.get(1);

        let abilities = wire.table.get(2);

        let content_size = wire.table.get(3);

        let storage_size = wire.table.get(4);

        let link_count = wire.table.get(5);

        let id = wire.table.get(6);

        let change_time = wire.table.get(7);

        let options = wire.table.get(8);

        let root_hash = wire.table.get(9);

        let verity_enabled = wire.table.get(10);

        Self {
            protocols: protocols.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeProtocolKinds>()
                })
            }),

            abilities: abilities.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireOperations>()
                })
            }),

            content_size: content_size.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            storage_size: storage_size.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            link_count: link_count.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            id: id.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            change_time: change_time.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),

            options: options.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireVerificationOptions<'de>>()
                })
            }),

            root_hash: root_hash.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),

            verity_enabled: verity_enabled.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireImmutableNodeAttributes<'de>> for ImmutableNodeAttributes {
    #[inline]
    fn from_wire_ref(wire: &WireImmutableNodeAttributes<'de>) -> Self {
        Self {
            protocols: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireNodeProtocolKinds>()
                })
            }),

            abilities: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireOperations>()
                })
            }),

            content_size: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            storage_size: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            link_count: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            id: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            change_time: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireU64>()
                })
            }),

            options: wire.table.get(8).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireVerificationOptions<'de>>()
                })
            }),

            root_hash: wire.table.get(9).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),

            verity_enabled: wire.table.get(10).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<bool>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ImmutableNodeAttributes`].
#[repr(C)]
pub struct WireImmutableNodeAttributes<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireImmutableNodeAttributes<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireNodeProtocolKinds>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireOperations>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });

        let _ = self.table.get(8).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireVerificationOptions<'de>>()
        });

        let _ = self.table.get(9).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
        });

        let _ = self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
    }
}

unsafe impl ::fidl_next::Wire for WireImmutableNodeAttributes<'static> {
    type Decoded<'de> = WireImmutableNodeAttributes<'de>;

    #[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<'static>
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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, 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<'de> WireImmutableNodeAttributes<'de> {
    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<'de>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn root_hash(&self) -> Option<&::fidl_next::WireVector<'de, 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<'de> ::core::fmt::Debug for WireImmutableNodeAttributes<'de> {
    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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.mutable_attributes, encoder, mutable_attributes)?;

        ::fidl_next::Encode::encode(self.immutable_attributes, encoder, immutable_attributes)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeAttributes2
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.mutable_attributes, encoder, mutable_attributes)?;

        ::fidl_next::EncodeRef::encode_ref(
            &self.immutable_attributes,
            encoder,
            immutable_attributes,
        )?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeAttributes2 {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeAttributes2<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeAttributes2
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes2: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeAttributes2
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAttributes2: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireNodeAttributes2<'de>> for NodeAttributes2 {
    #[inline]
    fn from_wire(wire: WireNodeAttributes2<'de>) -> Self {
        Self {
            mutable_attributes: ::fidl_next::FromWire::from_wire(wire.mutable_attributes),

            immutable_attributes: ::fidl_next::FromWire::from_wire(wire.immutable_attributes),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeAttributes2<'de>> for NodeAttributes2 {
    #[inline]
    fn from_wire_ref(wire: &WireNodeAttributes2<'de>) -> Self {
        Self {
            mutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.mutable_attributes),

            immutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
                &wire.immutable_attributes,
            ),
        }
    }
}

/// The wire type corresponding to [`NodeAttributes2`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeAttributes2<'de> {
    pub mutable_attributes: crate::WireMutableNodeAttributes<'de>,

    pub immutable_attributes: crate::WireImmutableNodeAttributes<'de>,
}

unsafe impl ::fidl_next::Wire for WireNodeAttributes2<'static> {
    type Decoded<'de> = WireNodeAttributes2<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAttributes2<'static>
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, Default)]
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<'static>;
}

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::Wire::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) = self.attributes.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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<'de> ::fidl_next::FromWire<WireNodeInfo<'de>> for NodeInfo {
    #[inline]
    fn from_wire(wire: WireNodeInfo<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let attributes = wire.table.get(1);

        Self {
            attributes: attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeInfo<'de>> for NodeInfo {
    #[inline]
    fn from_wire_ref(wire: &WireNodeInfo<'de>) -> Self {
        Self {
            attributes: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`NodeInfo`].
#[repr(C)]
pub struct WireNodeInfo<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireNodeInfo<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireNodeInfo<'static> {
    type Decoded<'de> = WireNodeInfo<'de>;

    #[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<'static>
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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireNodeInfo<'de> {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

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

#[derive(Clone, Debug, Default)]
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<'static>;
}

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::Wire::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) = self.attributes.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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<'de> ::fidl_next::FromWire<WireDirectoryInfo<'de>> for DirectoryInfo {
    #[inline]
    fn from_wire(wire: WireDirectoryInfo<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let attributes = wire.table.get(1);

        Self {
            attributes: attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireDirectoryInfo<'de>> for DirectoryInfo {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryInfo<'de>) -> Self {
        Self {
            attributes: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`DirectoryInfo`].
#[repr(C)]
pub struct WireDirectoryInfo<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireDirectoryInfo<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireDirectoryInfo<'static> {
    type Decoded<'de> = WireDirectoryInfo<'de>;

    #[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<'static>
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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireDirectoryInfo<'de> {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDirectoryInfo<'de> {
    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, Default)]
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.attributes.is_some() {
            return 4;
        }

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

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

        if self.is_append.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for FileInfo {
    type Encoded = WireFileInfo<'static>;
}

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::Wire::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) = self.attributes.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

                1 => {
                    if let Some(is_append) = self.is_append.take() {
                        ::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<'de> ::fidl_next::FromWire<WireFileInfo<'de>> for FileInfo {
    #[inline]
    fn from_wire(wire: WireFileInfo<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let is_append = wire.table.get(1);

        let observer = wire.table.get(2);

        let stream = wire.table.get(3);

        let attributes = wire.table.get(4);

        Self {
            is_append: is_append.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
            }),

            observer: observer.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),

            stream: stream.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),

            attributes: attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`FileInfo`].
#[repr(C)]
pub struct WireFileInfo<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireFileInfo<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireFileInfo<'static> {
    type Decoded<'de> = WireFileInfo<'de>;

    #[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<'static>
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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireFileInfo<'de> {
    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<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireFileInfo<'de> {
    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, Default)]
pub struct SymlinkInfo {
    pub target: Option<Vec<u8>>,

    pub attributes: Option<crate::NodeAttributes2>,
}

impl SymlinkInfo {
    fn __max_ordinal(&self) -> usize {
        if self.attributes.is_some() {
            return 2;
        }

        if self.target.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for SymlinkInfo {
    type Encoded = WireSymlinkInfo<'static>;
}

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::Wire::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) = self.attributes.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(target) = self.target.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SymlinkInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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<'de> ::fidl_next::FromWire<WireSymlinkInfo<'de>> for SymlinkInfo {
    #[inline]
    fn from_wire(wire: WireSymlinkInfo<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let target = wire.table.get(1);

        let attributes = wire.table.get(2);

        Self {
            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),

            attributes: attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireSymlinkInfo<'de>> for SymlinkInfo {
    #[inline]
    fn from_wire_ref(wire: &WireSymlinkInfo<'de>) -> Self {
        Self {
            target: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
                })
            }),

            attributes: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireNodeAttributes2<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`SymlinkInfo`].
#[repr(C)]
pub struct WireSymlinkInfo<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireSymlinkInfo<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
        });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireNodeAttributes2<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireSymlinkInfo<'static> {
    type Decoded<'de> = WireSymlinkInfo<'de>;

    #[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<'static>
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<'static, 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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireSymlinkInfo<'de> {
    pub fn target(&self) -> Option<&::fidl_next::WireVector<'de, u8>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn attributes(&self) -> Option<&crate::WireNodeAttributes2<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireSymlinkInfo<'de> {
    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<'static>;
}

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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRepresentation { raw, _phantom: _ } = 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 Representation {
    type EncodedOption = WireOptionalRepresentation<'static>;
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRepresentation<'de>> for Representation {
    #[inline]
    fn from_wire(wire: WireRepresentation<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireNodeInfo<'de>>()
            })),

            2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirectoryInfo<'de>>()
            })),

            3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireFileInfo<'de>>()
            })),

            4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireSymlinkInfo<'de>>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalRepresentation<'de>> for Box<Representation> {
    #[inline]
    fn from_wire_option(wire: WireOptionalRepresentation<'de>) -> Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(Box::new(::fidl_next::FromWire::from_wire(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`Representation`].
#[repr(transparent)]
pub struct WireRepresentation<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireRepresentation<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireNodeInfo<'de>>() };
            }

            2 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirectoryInfo<'de>>() };
            }

            3 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireFileInfo<'de>>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireSymlinkInfo<'de>>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireRepresentation<'static> {
    type Decoded<'de> = WireRepresentation<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod representation {
    pub enum Ref<'de> {
        Node(&'de crate::WireNodeInfo<'de>),

        Directory(&'de crate::WireDirectoryInfo<'de>),

        File(&'de crate::WireFileInfo<'de>),

        Symlink(&'de crate::WireSymlinkInfo<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireRepresentation<'de> {
    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<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireNodeInfo<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryInfo<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileInfo<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkInfo<'static>>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireRepresentation<'de> {
    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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalRepresentation<'static> {
    type Decoded<'de> = WireOptionalRepresentation<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalRepresentation<'de> {
    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<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireRepresentation<'de>> {
        if self.is_some() {
            Some(WireRepresentation { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalRepresentation<'static>
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, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireNodeInfo<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirectoryInfo<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireFileInfo<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireSymlinkInfo<'static>>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalRepresentation<'de> {
    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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeAttributesQuery
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireNodeAttributesQuery> for NodeAttributesQuery {
    #[inline]
    fn from_wire(wire: WireNodeAttributesQuery) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireNodeAttributesQuery> for NodeAttributesQuery {
    #[inline]
    fn from_wire_ref(wire: &WireNodeAttributesQuery) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireNodeAttributesQuery {
    type Decoded<'de> = Self;

    #[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, WireNodeGetAttributesRequest> = 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(
        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(self.query, encoder, query)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeGetAttributesRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.query, encoder, query)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeGetAttributesRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeGetAttributesRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeGetAttributesRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetAttributesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for NodeGetAttributesRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeGetAttributesRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireNodeGetAttributesRequest> for NodeGetAttributesRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireNodeGetAttributesRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <crate::NodeAttributesQuery as ::fidl_next::FromWire<
                crate::WireNodeAttributesQuery,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireNodeGetAttributesRequest) -> Self {
        Self { query: ::fidl_next::FromWire::from_wire(wire.query) }
    }
}

impl ::fidl_next::FromWireRef<WireNodeGetAttributesRequest> for NodeGetAttributesRequest {
    #[inline]
    fn from_wire_ref(wire: &WireNodeGetAttributesRequest) -> Self {
        Self { query: ::fidl_next::FromWireRef::from_wire_ref(&wire.query) }
    }
}

/// The wire type corresponding to [`NodeGetAttributesRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireNodeGetAttributesRequest {
    pub query: crate::WireNodeAttributesQuery,
}

unsafe impl ::fidl_next::Wire for WireNodeGetAttributesRequest {
    type Decoded<'de> = 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 = "fuchsia.io.Node";
}

pub mod node {
    pub mod prelude {
        pub use crate::{node, Node, NodeClientHandler, NodeServerHandler};

        pub use crate::ExtendedAttributeValue;

        pub use crate::MutableNodeAttributes;

        pub use crate::NodeAttributes2;

        pub use crate::NodeDeprecatedCloneRequest;

        pub use crate::NodeDeprecatedGetAttrResponse;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetAttrRequest;

        pub use crate::NodeDeprecatedSetAttrResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        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::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<
            'static,
            ::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<'static>;
    }

    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<'static>;
    }

    pub struct DeprecatedGetAttr;

    impl ::fidl_next::Method for DeprecatedGetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Node;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetAttrResponse;
    }

    pub struct DeprecatedSetAttr;

    impl ::fidl_next::Method for DeprecatedSetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Node;

        type Request = crate::WireNodeDeprecatedSetAttrRequest;

        type Response = crate::WireNodeDeprecatedSetAttrResponse;
    }

    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<
            'static,
            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<
            'static,
            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<'static>;
    }

    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<'static>;
    }

    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<
            'static,
            crate::WireNodeAttributes2<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Node;

        type Request = crate::WireMutableNodeAttributes<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static, 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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireExtendedAttributeValue<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Node;

        type Request = crate::WireNodeSetExtendedAttributeRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireNodeRemoveExtendedAttributeResponse,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        pub struct Clone<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for Clone<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct DeprecatedClone<T0, T1> {
            flags: T0,

            object: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedClone<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            type Encoded = crate::WireNodeDeprecatedCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct OnOpen<T0, T1> {
            s: T0,

            info: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for OnOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            type Encoded = crate::WireNodeOnOpenRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            #[inline]
            fn encode(
                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(self.s, encoder, s)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetAttr<T0, T1> {
            flags: T0,

            attributes: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedSetAttr<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributes>,
        {
            type Encoded = crate::WireNodeDeprecatedSetAttrRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributes>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for DeprecatedSetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,
        {
            type Encoded = crate::WireNodeDeprecatedSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct SetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for SetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireFlags>,
        {
            type Encoded = crate::WireNodeSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct GetAttributes<T0> {
            query: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetAttributes<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributesQuery>,
        {
            type Encoded = crate::WireNodeGetAttributesRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributesQuery>,
        {
            #[inline]
            fn encode(
                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(self.query, encoder, query)?;

                Ok(())
            }
        }

        pub struct ListExtendedAttributes<T0> {
            iterator: T0,
        }

        impl<T0> ::fidl_next::Encodable for ListExtendedAttributes<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireNodeListExtendedAttributesRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.iterator, encoder, iterator)?;

                Ok(())
            }
        }

        pub struct GetExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct SetExtendedAttribute<T0, T1, T2> {
            name: T0,

            value: T1,

            mode: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for SetExtendedAttribute<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireSetExtendedAttributeMode>,
        {
            type Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for SetExtendedAttribute<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireSetExtendedAttributeMode>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

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

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

                Ok(())
            }
        }

        pub struct RemoveExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for RemoveExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Node
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = NodeClientSender<___T>;
            type ServerSender = NodeServerSender<___T>;
        }

        /// The client sender for the `Node` protocol.
        pub struct NodeClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> NodeClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn clone(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_unknown::Cloneable,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.clone_with(Clone { request })
            }

            pub fn clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
                >,
            {
                self.sender.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"]
            pub fn close(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Close, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(6540867515453498750, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn query(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Query, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(2763219980499352582, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Node,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.deprecated_clone_with(DeprecatedClone { flags, object })
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedCloneRequest,
                >,
            {
                self.sender.send_one_way(6512600400724287855, request)
            }

            #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
            pub fn deprecated_get_attr(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetAttr, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8689798978500614909, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributeFlags,
                >,

                attributes: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributes,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_attr_with(DeprecatedSetAttr { flags, attributes })
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetAttrRequest,
                >,
            {
                self.sender
                    .send_two_way(4721673413776871238, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
            pub fn deprecated_get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(6595803110182632097, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_flags_with(DeprecatedSetFlags { flags })
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(105530239381466147, ())
                    .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"]
            pub fn set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.set_flags_with(SetFlags { flags })
            }

            #[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"]
            pub fn set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetFlagsRequest,
                >,
            {
                self.sender
                    .send_two_way(6172186066099445416, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " Query the filesystem for filesystem-specific information.\n"]
            pub fn query_filesystem(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::QueryFilesystem, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8013111122914313744, ())
                    .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"]
            pub fn get_attributes(
                &self,

                query: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributesQuery,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_attributes_with(GetAttributes { query })
            }

            #[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"]
            pub fn get_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetAttributesRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn update_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::UpdateAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireMutableNodeAttributes<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn sync(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Sync, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(3196473584242777161, ())
                    .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"]
            pub fn list_extended_attributes(
                &self,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::ExtendedAttributeIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.list_extended_attributes_with(ListExtendedAttributes { iterator })
            }

            #[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"]
            pub fn list_extended_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeListExtendedAttributesRequest,
                >,
            {
                self.sender.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"]
            pub fn get_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.get_extended_attribute_with(GetExtendedAttribute { name })
            }

            #[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"]
            pub fn get_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn set_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                value: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireExtendedAttributeValue<'static>,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireSetExtendedAttributeMode,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.set_extended_attribute_with(SetExtendedAttribute { name, value, mode })
            }

            #[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"]
            pub fn set_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn remove_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.remove_extended_attribute_with(RemoveExtendedAttribute { name })
            }

            #[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"]
            pub fn remove_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(8794297771444732717, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Node` protocol.
        #[repr(transparent)]
        pub struct NodeServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> NodeServerSender<___T>
        where
            ___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"]
            pub fn on_open(
                &self,

                s: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireI32,
                >,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOptionalNodeInfoDeprecated<'static>,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.on_open_with(OnOpen { s, info })
            }

            #[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"]

            pub fn on_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnOpen as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.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"]

            pub fn on_representation_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnRepresentation as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(6679970090861613324, request)
            }
        }
    }
}

/// 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<Node, ___T>,

        event: ::fidl_next::Response<node::OnOpen, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        event: ::fidl_next::Response<node::OnRepresentation, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<Node, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Node
where
    ___H: NodeClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <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::DeprecatedGetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedSetAttr 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::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>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_representation(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// 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<Node, ___T>,

        request: ::fidl_next::Request<node::Clone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        responder: ::fidl_next::Responder<node::Close>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        responder: ::fidl_next::Responder<node::Query>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        request: ::fidl_next::Request<node::DeprecatedClone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
    fn deprecated_get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        responder: ::fidl_next::Responder<node::DeprecatedGetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
    fn deprecated_set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,

        responder: ::fidl_next::Responder<node::DeprecatedSetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        responder: ::fidl_next::Responder<node::DeprecatedGetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,

        responder: ::fidl_next::Responder<node::DeprecatedSetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        responder: ::fidl_next::Responder<node::GetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::SetFlags, ___T>,

        responder: ::fidl_next::Responder<node::SetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,

        responder: ::fidl_next::Responder<node::QueryFilesystem>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::GetAttributes, ___T>,

        responder: ::fidl_next::Responder<node::GetAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::UpdateAttributes, ___T>,

        responder: ::fidl_next::Responder<node::UpdateAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        responder: ::fidl_next::Responder<node::Sync>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<node::GetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<node::SetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Node, ___T>,

        request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<node::RemoveExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<Node, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Node
where
    ___H: NodeServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <node::Clone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedClone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedSetAttr as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::DeprecatedSetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::SetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::UpdateAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::ListExtendedAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::GetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::SetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.deprecated_clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.list_extended_attributes(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        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).await;
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder).await;
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_attr(sender, responder).await;
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_attr(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder).await;
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder).await;
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder).await;
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.update_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder).await;
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.remove_extended_attribute(sender, decoded, responder).await
                    }
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Debug)]
pub struct DirectoryDeprecatedOpenRequest {
    pub flags: crate::OpenFlags,

    pub mode: crate::ModeType,

    pub path: String,

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

impl ::fidl_next::Encodable for DirectoryDeprecatedOpenRequest {
    type Encoded = WireDirectoryDeprecatedOpenRequest<'static>;
}

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(
        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(self.flags, encoder, flags)?;

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

        ::fidl_next::Encode::encode(self.path, encoder, path)?;

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DirectoryDeprecatedOpenRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDirectoryDeprecatedOpenRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryDeprecatedOpenRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryDeprecatedOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireDirectoryDeprecatedOpenRequest<'de>>
    for DirectoryDeprecatedOpenRequest
{
    #[inline]
    fn from_wire(wire: WireDirectoryDeprecatedOpenRequest<'de>) -> Self {
        Self {
            flags: ::fidl_next::FromWire::from_wire(wire.flags),

            mode: ::fidl_next::FromWire::from_wire(wire.mode),

            path: ::fidl_next::FromWire::from_wire(wire.path),

            object: ::fidl_next::FromWire::from_wire(wire.object),
        }
    }
}

/// The wire type corresponding to [`DirectoryDeprecatedOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryDeprecatedOpenRequest<'de> {
    pub flags: crate::WireOpenFlags,

    pub mode: crate::WireModeType,

    pub path: ::fidl_next::WireString<'de>,

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

unsafe impl ::fidl_next::Wire for WireDirectoryDeprecatedOpenRequest<'static> {
    type Decoded<'de> = WireDirectoryDeprecatedOpenRequest<'de>;

    #[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<'static>
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, Default)]
pub struct Options {
    pub attributes: Option<crate::NodeAttributesQuery>,

    pub create_attributes: Option<crate::MutableNodeAttributes>,
}

impl Options {
    fn __max_ordinal(&self) -> usize {
        if self.create_attributes.is_some() {
            return 2;
        }

        if self.attributes.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Options {
    type Encoded = WireOptions<'static>;
}

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::Wire::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) = self.create_attributes.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            create_attributes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(attributes) = self.attributes.take() {
                        ::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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Options
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::Wire::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) = &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) = &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<'de> ::fidl_next::FromWire<WireOptions<'de>> for Options {
    #[inline]
    fn from_wire(wire: WireOptions<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let attributes = wire.table.get(1);

        let create_attributes = wire.table.get(2);

        Self {
            attributes: attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireNodeAttributesQuery>()
                })
            }),

            create_attributes: create_attributes.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireMutableNodeAttributes<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOptions<'de>> for Options {
    #[inline]
    fn from_wire_ref(wire: &WireOptions<'de>) -> Self {
        Self {
            attributes: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireNodeAttributesQuery>()
                })
            }),

            create_attributes: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireMutableNodeAttributes<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`Options`].
#[repr(C)]
pub struct WireOptions<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOptions<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireNodeAttributesQuery>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireMutableNodeAttributes<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireOptions<'static> {
    type Decoded<'de> = WireOptions<'de>;

    #[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<'static>
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<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireOptions<'de> {
    pub fn attributes(&self) -> Option<&crate::WireNodeAttributesQuery> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn create_attributes(&self) -> Option<&crate::WireMutableNodeAttributes<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOptions<'de> {
    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<'static>;
}

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(
        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(self.path, encoder, path)?;

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DirectoryOpenRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDirectoryOpenRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryOpenRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryOpenRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireDirectoryOpenRequest<'de>> for DirectoryOpenRequest {
    #[inline]
    fn from_wire(wire: WireDirectoryOpenRequest<'de>) -> Self {
        Self {
            path: ::fidl_next::FromWire::from_wire(wire.path),

            flags: ::fidl_next::FromWire::from_wire(wire.flags),

            options: ::fidl_next::FromWire::from_wire(wire.options),

            object: ::fidl_next::FromWire::from_wire(wire.object),
        }
    }
}

/// The wire type corresponding to [`DirectoryOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryOpenRequest<'de> {
    pub path: ::fidl_next::WireString<'de>,

    pub flags: crate::WireFlags,

    pub options: crate::WireOptions<'de>,

    pub object: ::fidl_next::fuchsia::WireHandle,
}

unsafe impl ::fidl_next::Wire for WireDirectoryOpenRequest<'static> {
    type Decoded<'de> = WireDirectoryOpenRequest<'de>;

    #[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<'static>
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:
        Option<::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::zx::Channel>>,
}

impl ::fidl_next::Encodable for DirectoryCreateSymlinkRequest {
    type Encoded = WireDirectoryCreateSymlinkRequest<'static>;
}

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(
        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(self.name, encoder, name)?;

        ::fidl_next::Encode::encode(self.target, encoder, target)?;

        ::fidl_next::Encode::encode(self.connection, encoder, connection)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DirectoryCreateSymlinkRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDirectoryCreateSymlinkRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryCreateSymlinkRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryCreateSymlinkRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireDirectoryCreateSymlinkRequest<'de>>
    for DirectoryCreateSymlinkRequest
{
    #[inline]
    fn from_wire(wire: WireDirectoryCreateSymlinkRequest<'de>) -> Self {
        Self {
            name: ::fidl_next::FromWire::from_wire(wire.name),

            target: ::fidl_next::FromWire::from_wire(wire.target),

            connection: ::fidl_next::FromWire::from_wire(wire.connection),
        }
    }
}

/// The wire type corresponding to [`DirectoryCreateSymlinkRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirectoryCreateSymlinkRequest<'de> {
    pub name: ::fidl_next::WireString<'de>,

    pub target: ::fidl_next::WireVector<'de, u8>,

    pub connection:
        ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::WireOptionalChannel>,
}

unsafe impl ::fidl_next::Wire for WireDirectoryCreateSymlinkRequest<'static> {
    type Decoded<'de> = WireDirectoryCreateSymlinkRequest<'de>;

    #[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<'static>
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 = "fuchsia.io.Directory";
}

pub mod directory {
    pub mod prelude {
        pub use crate::{directory, Directory, DirectoryClientHandler, DirectoryServerHandler};

        pub use crate::AdvisoryLockingAdvisoryLockRequest;

        pub use crate::AdvisoryLockingAdvisoryLockResponse;

        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::NodeDeprecatedGetAttrResponse;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetAttrRequest;

        pub use crate::NodeDeprecatedSetAttrResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        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::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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<
            'static,
            ::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<'static>;
    }

    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<'static>;
    }

    pub struct DeprecatedGetAttr;

    impl ::fidl_next::Method for DeprecatedGetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Directory;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetAttrResponse;
    }

    pub struct DeprecatedSetAttr;

    impl ::fidl_next::Method for DeprecatedSetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeDeprecatedSetAttrRequest;

        type Response = crate::WireNodeDeprecatedSetAttrResponse;
    }

    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<
            'static,
            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<
            'static,
            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<'static>;
    }

    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<'static>;
    }

    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<
            'static,
            crate::WireNodeAttributes2<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Directory;

        type Request = crate::WireMutableNodeAttributes<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static, 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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireExtendedAttributeValue<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Directory;

        type Request = crate::WireNodeSetExtendedAttributeRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        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<'static>;

        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<'static>;
    }

    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<'static>;

        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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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;
    }

    mod ___detail {

        pub struct AdvisoryLock<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for AdvisoryLock<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            type Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct Clone<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for Clone<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct DeprecatedClone<T0, T1> {
            flags: T0,

            object: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedClone<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            type Encoded = crate::WireNodeDeprecatedCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct OnOpen<T0, T1> {
            s: T0,

            info: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for OnOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            type Encoded = crate::WireNodeOnOpenRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            #[inline]
            fn encode(
                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(self.s, encoder, s)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetAttr<T0, T1> {
            flags: T0,

            attributes: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedSetAttr<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributes>,
        {
            type Encoded = crate::WireNodeDeprecatedSetAttrRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributes>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for DeprecatedSetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,
        {
            type Encoded = crate::WireNodeDeprecatedSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct SetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for SetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireFlags>,
        {
            type Encoded = crate::WireNodeSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct GetAttributes<T0> {
            query: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetAttributes<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributesQuery>,
        {
            type Encoded = crate::WireNodeGetAttributesRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributesQuery>,
        {
            #[inline]
            fn encode(
                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(self.query, encoder, query)?;

                Ok(())
            }
        }

        pub struct ListExtendedAttributes<T0> {
            iterator: T0,
        }

        impl<T0> ::fidl_next::Encodable for ListExtendedAttributes<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireNodeListExtendedAttributesRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.iterator, encoder, iterator)?;

                Ok(())
            }
        }

        pub struct GetExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct SetExtendedAttribute<T0, T1, T2> {
            name: T0,

            value: T1,

            mode: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for SetExtendedAttribute<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireSetExtendedAttributeMode>,
        {
            type Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for SetExtendedAttribute<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireSetExtendedAttributeMode>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

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

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

                Ok(())
            }
        }

        pub struct RemoveExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for RemoveExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct DeprecatedOpen<T0, T1, T2, T3> {
            flags: T0,

            mode: T1,

            path: T2,

            object: T3,
        }

        impl<T0, T1, T2, T3> ::fidl_next::Encodable for DeprecatedOpen<T0, T1, T2, T3>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireModeType>,

            T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T3: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            type Encoded = crate::WireDirectoryDeprecatedOpenRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<___E> for DeprecatedOpen<T0, T1, T2, T3>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireModeType>,

            T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T3: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                ::fidl_next::Encode::encode(self.path, encoder, path)?;

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

                Ok(())
            }
        }

        pub struct Open<T0, T1, T2, T3> {
            path: T0,

            flags: T1,

            options: T2,

            object: T3,
        }

        impl<T0, T1, T2, T3> ::fidl_next::Encodable for Open<T0, T1, T2, T3>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireFlags>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireOptions<'static>>,

            T3: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireDirectoryOpenRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2, T3> ::fidl_next::Encode<___E> for Open<T0, T1, T2, T3>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireFlags>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireOptions<'static>>,

            T3: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            #[inline]
            fn encode(
                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(self.path, encoder, path)?;

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

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

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

                Ok(())
            }
        }

        pub struct ReadDirents<T0> {
            max_bytes: T0,
        }

        impl<T0> ::fidl_next::Encodable for ReadDirents<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireDirectoryReadDirentsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.max_bytes, encoder, max_bytes)?;

                Ok(())
            }
        }

        pub struct Link<T0, T1, T2> {
            src: T0,

            dst_parent_token: T1,

            dst: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for Link<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,

            T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireDirectoryLinkRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for Link<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,

            T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                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(self.src, encoder, src)?;

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

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

                Ok(())
            }
        }

        pub struct Unlink<T0, T1> {
            name: T0,

            options: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Unlink<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireUnlinkOptions<'static>>,
        {
            type Encoded = crate::WireDirectoryUnlinkRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireUnlinkOptions<'static>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

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

                Ok(())
            }
        }

        pub struct Rename<T0, T1, T2> {
            src: T0,

            dst_parent_token: T1,

            dst: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for Rename<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,

            T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireDirectoryRenameRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for Rename<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,

            T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                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(self.src, encoder, src)?;

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

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

                Ok(())
            }
        }

        pub struct CreateSymlink<T0, T1, T2> {
            name: T0,

            target: T1,

            connection: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for CreateSymlink<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T2: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::Symlink,
                    ::fidl_next::fuchsia::WireOptionalChannel,
                >,
            >,
        {
            type Encoded = crate::WireDirectoryCreateSymlinkRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for CreateSymlink<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T2: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::Symlink,
                    ::fidl_next::fuchsia::WireOptionalChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                ::fidl_next::Encode::encode(self.target, encoder, target)?;

                ::fidl_next::Encode::encode(self.connection, encoder, connection)?;

                Ok(())
            }
        }

        pub struct Watch<T0, T1, T2> {
            mask: T0,

            options: T1,

            watcher: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for Watch<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireWatchMask>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,

            T2: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::DirectoryWatcher,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireDirectoryWatchRequest;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for Watch<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireWatchMask>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,

            T2: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::DirectoryWatcher,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.mask, encoder, mask)?;

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

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Directory
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirectoryClientSender<___T>;
            type ServerSender = DirectoryServerSender<___T>;
        }

        /// The client sender for the `Directory` protocol.
        pub struct DirectoryClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> DirectoryClientSender<___T>
        where
            ___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"]
            pub fn advisory_lock(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockRequest<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.advisory_lock_with(AdvisoryLock { request })
            }

            #[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"]
            pub fn advisory_lock_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(7992130864415541162, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn clone(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_unknown::Cloneable,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.clone_with(Clone { request })
            }

            pub fn clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
                >,
            {
                self.sender.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"]
            pub fn close(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Close, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(6540867515453498750, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn query(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Query, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(2763219980499352582, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Node,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.deprecated_clone_with(DeprecatedClone { flags, object })
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedCloneRequest,
                >,
            {
                self.sender.send_one_way(6512600400724287855, request)
            }

            #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
            pub fn deprecated_get_attr(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetAttr, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8689798978500614909, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributeFlags,
                >,

                attributes: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributes,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_attr_with(DeprecatedSetAttr { flags, attributes })
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetAttrRequest,
                >,
            {
                self.sender
                    .send_two_way(4721673413776871238, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
            pub fn deprecated_get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(6595803110182632097, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_flags_with(DeprecatedSetFlags { flags })
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(105530239381466147, ())
                    .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"]
            pub fn set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.set_flags_with(SetFlags { flags })
            }

            #[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"]
            pub fn set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetFlagsRequest,
                >,
            {
                self.sender
                    .send_two_way(6172186066099445416, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " Query the filesystem for filesystem-specific information.\n"]
            pub fn query_filesystem(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::QueryFilesystem, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8013111122914313744, ())
                    .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"]
            pub fn get_attributes(
                &self,

                query: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributesQuery,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_attributes_with(GetAttributes { query })
            }

            #[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"]
            pub fn get_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetAttributesRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn update_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::UpdateAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireMutableNodeAttributes<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn sync(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Sync, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(3196473584242777161, ())
                    .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"]
            pub fn list_extended_attributes(
                &self,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::ExtendedAttributeIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.list_extended_attributes_with(ListExtendedAttributes { iterator })
            }

            #[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"]
            pub fn list_extended_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeListExtendedAttributesRequest,
                >,
            {
                self.sender.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"]
            pub fn get_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.get_extended_attribute_with(GetExtendedAttribute { name })
            }

            #[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"]
            pub fn get_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn set_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                value: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireExtendedAttributeValue<'static>,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireSetExtendedAttributeMode,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.set_extended_attribute_with(SetExtendedAttribute { name, value, mode })
            }

            #[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"]
            pub fn set_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn remove_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.remove_extended_attribute_with(RemoveExtendedAttribute { name })
            }

            #[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"]
            pub fn remove_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(8794297771444732717, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
            pub fn deprecated_open(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireModeType,
                >,

                path: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Node,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.deprecated_open_with(DeprecatedOpen { flags, mode, path, object })
            }

            #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
            pub fn deprecated_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryDeprecatedOpenRequest<'static>,
                >,
            {
                self.sender.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"]
            pub fn open(
                &self,

                path: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFlags,
                >,

                options: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOptions<'static>,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.open_with(Open { path, flags, options, object })
            }

            #[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"]
            pub fn open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryOpenRequest<'static>,
                >,
            {
                self.sender.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"]
            pub fn read_dirents(
                &self,

                max_bytes: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ReadDirents, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.read_dirents_with(ReadDirents { max_bytes })
            }

            #[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"]
            pub fn read_dirents_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ReadDirents, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryReadDirentsRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn rewind(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Rewind, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(1635123508515392625, ())
                    .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"]
            pub fn get_token(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetToken, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(2787337947777369685, ())
                    .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"]
            pub fn link(
                &self,

                src: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                dst_parent_token: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,

                dst: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Link, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.link_with(Link { src, dst_parent_token, dst })
            }

            #[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"]
            pub fn link_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Link, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryLinkRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn unlink(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                options: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireUnlinkOptions<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Unlink, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.unlink_with(Unlink { name, options })
            }

            #[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"]
            pub fn unlink_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Unlink, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryUnlinkRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn rename(
                &self,

                src: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                dst_parent_token: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,

                dst: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Rename, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.rename_with(Rename { src, dst_parent_token, dst })
            }

            #[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"]
            pub fn rename_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Rename, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryRenameRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn create_symlink(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                target: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                connection: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Symlink,
                        ::fidl_next::fuchsia::WireOptionalChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::CreateSymlink, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.create_symlink_with(CreateSymlink { name, target, connection })
            }

            #[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"]
            pub fn create_symlink_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::CreateSymlink, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryCreateSymlinkRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn watch(
                &self,

                mask: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireWatchMask,
                >,

                options: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU32,
                >,

                watcher: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::DirectoryWatcher,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Watch, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.watch_with(Watch { mask, options, watcher })
            }

            #[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"]
            pub fn watch_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Watch, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirectoryWatchRequest,
                >,
            {
                self.sender
                    .send_two_way(6275512344170098065, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Directory` protocol.
        #[repr(transparent)]
        pub struct DirectoryServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> DirectoryServerSender<___T>
        where
            ___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"]
            pub fn on_open(
                &self,

                s: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireI32,
                >,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOptionalNodeInfoDeprecated<'static>,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.on_open_with(OnOpen { s, info })
            }

            #[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"]

            pub fn on_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnOpen as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.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"]

            pub fn on_representation_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnRepresentation as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(6679970090861613324, request)
            }
        }
    }
}

/// 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<Directory, ___T>,

        event: ::fidl_next::Response<directory::OnOpen, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        event: ::fidl_next::Response<directory::OnRepresentation, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<Directory, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Directory
where
    ___H: DirectoryClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <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::DeprecatedGetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedSetAttr 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::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>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_representation(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// 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<Directory, ___T>,

        request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,

        responder: ::fidl_next::Responder<directory::AdvisoryLock>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        request: ::fidl_next::Request<directory::Clone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::Close>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::Query>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        request: ::fidl_next::Request<directory::DeprecatedClone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
    fn deprecated_get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::DeprecatedGetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
    fn deprecated_set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,

        responder: ::fidl_next::Responder<directory::DeprecatedSetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::DeprecatedGetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,

        responder: ::fidl_next::Responder<directory::DeprecatedSetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::GetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::SetFlags, ___T>,

        responder: ::fidl_next::Responder<directory::SetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::QueryFilesystem>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::GetAttributes, ___T>,

        responder: ::fidl_next::Responder<directory::GetAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,

        responder: ::fidl_next::Responder<directory::UpdateAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::Sync>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<directory::GetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<directory::SetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
    fn deprecated_open(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,

        request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::Open, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::ReadDirents, ___T>,

        responder: ::fidl_next::Responder<directory::ReadDirents>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::Rewind>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        responder: ::fidl_next::Responder<directory::GetToken>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::Link, ___T>,

        responder: ::fidl_next::Responder<directory::Link>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::Unlink, ___T>,

        responder: ::fidl_next::Responder<directory::Unlink>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::Rename, ___T>,

        responder: ::fidl_next::Responder<directory::Rename>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::CreateSymlink, ___T>,

        responder: ::fidl_next::Responder<directory::CreateSymlink>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Directory, ___T>,

        request: ::fidl_next::Request<directory::Watch, ___T>,

        responder: ::fidl_next::Responder<directory::Watch>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<Directory, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Directory
where
    ___H: DirectoryServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <directory::AdvisoryLock as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Clone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedClone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedSetAttr as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedSetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::SetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::UpdateAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::ListExtendedAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::GetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::SetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::DeprecatedOpen as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Open as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::ReadDirents as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Link as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Unlink as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Rename as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::CreateSymlink as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <directory::Watch as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.deprecated_clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.list_extended_attributes(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            3193127272456937152 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.deprecated_open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6236883748953765593 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.advisory_lock(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder).await;
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder).await;
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_attr(sender, responder).await;
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_attr(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder).await;
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder).await;
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder).await;
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.update_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder).await;
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.remove_extended_attribute(sender, decoded, responder).await
                    }
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3855785432100874762 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.read_dirents(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            1635123508515392625 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.rewind(sender, responder).await;
            }

            2787337947777369685 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_token(sender, responder).await;
            }

            8360374984291987687 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.link(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8433556716759383021 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.unlink(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8097726607824333022 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.rename(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            2435901052462315657 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.create_symlink(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6275512344170098065 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.watch(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct DirectoryObject {}

impl ::fidl_next::Encodable for DirectoryObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirectoryObject> =
        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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirectoryObject
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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 DirectoryObject {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDirectoryObject>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryObject
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DirectoryObject
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DirectoryObject: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireDirectoryObject> for DirectoryObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirectoryObject, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn from_wire(wire: WireDirectoryObject) -> Self {
        Self {}
    }
}

impl ::fidl_next::FromWireRef<WireDirectoryObject> for DirectoryObject {
    #[inline]
    fn from_wire_ref(wire: &WireDirectoryObject) -> Self {
        Self {}
    }
}

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

unsafe impl ::fidl_next::Wire for WireDirectoryObject {
    type Decoded<'de> = 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,
            DirectoryWatcherServerHandler,
        };
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirectoryWatcher
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirectoryWatcherClientSender<___T>;
            type ServerSender = DirectoryWatcherServerSender<___T>;
        }

        /// The client sender for the `DirectoryWatcher` protocol.
        pub struct DirectoryWatcherClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> DirectoryWatcherClientSender<___T> where ___T: ::fidl_next::Transport {}

        /// The server sender for the `DirectoryWatcher` protocol.
        #[repr(transparent)]
        pub struct DirectoryWatcherServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> DirectoryWatcherServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DirectoryWatcher
where
    ___H: DirectoryWatcherClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A server handler for the DirectoryWatcher protocol.
///
/// See [`DirectoryWatcher`] for more details.
pub trait DirectoryWatcherServerHandler<___T: ::fidl_next::Transport> {}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DirectoryWatcher
where
    ___H: DirectoryWatcherServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        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;
}
impl ::std::convert::From<u8> for DirentType {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::Unknown,
            4 => Self::Directory,
            6 => Self::BlockDevice,
            8 => Self::File,
            10 => Self::Symlink,
            16 => Self::Service,

            _ => Self::UnknownOrdinal_(value),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirentType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DirentType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireDirentType> for DirentType {
    #[inline]
    fn from_wire(wire: WireDirentType) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireDirentType> for DirentType {
    #[inline]
    fn from_wire_ref(wire: &WireDirentType) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireDirentType {
    type Decoded<'de> = Self;

    #[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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.attributes, encoder, attributes)?;

        ::fidl_next::Encode::encode(self.last, encoder, last)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExtendedAttributeIteratorGetNextResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.attributes, encoder, attributes)?;

        ::fidl_next::EncodeRef::encode_ref(&self.last, encoder, last)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ExtendedAttributeIteratorGetNextResponse {
    type EncodedOption =
        ::fidl_next::WireBox<'static, WireExtendedAttributeIteratorGetNextResponse<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ExtendedAttributeIteratorGetNextResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for ExtendedAttributeIteratorGetNextResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ExtendedAttributeIteratorGetNextResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireExtendedAttributeIteratorGetNextResponse<'de>>
    for ExtendedAttributeIteratorGetNextResponse
{
    #[inline]
    fn from_wire(wire: WireExtendedAttributeIteratorGetNextResponse<'de>) -> Self {
        Self {
            attributes: ::fidl_next::FromWire::from_wire(wire.attributes),

            last: ::fidl_next::FromWire::from_wire(wire.last),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExtendedAttributeIteratorGetNextResponse<'de>>
    for ExtendedAttributeIteratorGetNextResponse
{
    #[inline]
    fn from_wire_ref(wire: &WireExtendedAttributeIteratorGetNextResponse<'de>) -> Self {
        Self {
            attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),

            last: ::fidl_next::FromWireRef::from_wire_ref(&wire.last),
        }
    }
}

/// The wire type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireExtendedAttributeIteratorGetNextResponse<'de> {
    pub attributes: ::fidl_next::WireVector<'de, ::fidl_next::WireVector<'de, u8>>,

    pub last: bool,
}

unsafe impl ::fidl_next::Wire for WireExtendedAttributeIteratorGetNextResponse<'static> {
    type Decoded<'de> = WireExtendedAttributeIteratorGetNextResponse<'de>;

    #[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<'static>
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, ExtendedAttributeIteratorServerHandler,
        };

        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<
            'static,
            crate::WireExtendedAttributeIteratorGetNextResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ExtendedAttributeIterator
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ExtendedAttributeIteratorClientSender<___T>;
            type ServerSender = ExtendedAttributeIteratorServerSender<___T>;
        }

        /// The client sender for the `ExtendedAttributeIterator` protocol.
        pub struct ExtendedAttributeIteratorClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> ExtendedAttributeIteratorClientSender<___T>
        where
            ___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"]
            pub fn get_next(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetNext, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(268639596268373415, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `ExtendedAttributeIterator` protocol.
        #[repr(transparent)]
        pub struct ExtendedAttributeIteratorServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> ExtendedAttributeIteratorServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for ExtendedAttributeIterator
where
    ___H: ExtendedAttributeIteratorClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

/// 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<ExtendedAttributeIterator, ___T>,

        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for ExtendedAttributeIterator
where
    ___H: ExtendedAttributeIteratorServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        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).await;
            }

            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, WireReadableReadRequest> = 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(
        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(self.count, encoder, count)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ReadableReadRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.count, encoder, count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ReadableReadRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireReadableReadRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ReadableReadRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for ReadableReadRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireReadableReadRequest> for ReadableReadRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireReadableReadRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireReadableReadRequest) -> Self {
        Self { count: ::fidl_next::FromWire::from_wire(wire.count) }
    }
}

impl ::fidl_next::FromWireRef<WireReadableReadRequest> for ReadableReadRequest {
    #[inline]
    fn from_wire_ref(wire: &WireReadableReadRequest) -> Self {
        Self { count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireReadableReadRequest {
    type Decoded<'de> = 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<'de> = ::fidl_next::WireVector<'de, u8>;

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

impl ::fidl_next::Encodable for ReadableReadResponse {
    type Encoded = WireReadableReadResponse<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.data, encoder, data)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ReadableReadResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ReadableReadResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireReadableReadResponse<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ReadableReadResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for ReadableReadResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ReadableReadResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireReadableReadResponse<'de>> for ReadableReadResponse {
    #[inline]
    fn from_wire(wire: WireReadableReadResponse<'de>) -> Self {
        Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireReadableReadResponse<'de>> for ReadableReadResponse {
    #[inline]
    fn from_wire_ref(wire: &WireReadableReadResponse<'de>) -> Self {
        Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
    }
}

/// The wire type corresponding to [`ReadableReadResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireReadableReadResponse<'de> {
    pub data: ::fidl_next::WireVector<'de, u8>,
}

unsafe impl ::fidl_next::Wire for WireReadableReadResponse<'static> {
    type Decoded<'de> = WireReadableReadResponse<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireReadableReadResponse<'static>
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, ReadableServerHandler};

        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<
            'static,
            crate::WireReadableReadResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        pub struct Read<T0> {
            count: T0,
        }

        impl<T0> ::fidl_next::Encodable for Read<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireReadableReadRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.count, encoder, count)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Readable
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ReadableClientSender<___T>;
            type ServerSender = ReadableServerSender<___T>;
        }

        /// The client sender for the `Readable` protocol.
        pub struct ReadableClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> ReadableClientSender<___T>
        where
            ___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"]
            pub fn read(
                &self,

                count: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Read, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.read_with(Read { count })
            }

            #[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"]
            pub fn read_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Read, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireReadableReadRequest,
                >,
            {
                self.sender
                    .send_two_way(395825947633028830, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Readable` protocol.
        #[repr(transparent)]
        pub struct ReadableServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> ReadableServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Readable
where
    ___H: ReadableClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

/// 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<Readable, ___T>,

        request: ::fidl_next::Request<readable::Read, ___T>,

        responder: ::fidl_next::Responder<readable::Read>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Readable
where
    ___H: ReadableServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.read(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

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

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

impl ::fidl_next::Encodable for WritableWriteRequest {
    type Encoded = WireWritableWriteRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.data, encoder, data)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WritableWriteRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for WritableWriteRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireWritableWriteRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WritableWriteRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WritableWriteRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireWritableWriteRequest<'de>> for WritableWriteRequest {
    #[inline]
    fn from_wire(wire: WireWritableWriteRequest<'de>) -> Self {
        Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireWritableWriteRequest<'de>> for WritableWriteRequest {
    #[inline]
    fn from_wire_ref(wire: &WireWritableWriteRequest<'de>) -> Self {
        Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
    }
}

/// The wire type corresponding to [`WritableWriteRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireWritableWriteRequest<'de> {
    pub data: ::fidl_next::WireVector<'de, u8>,
}

unsafe impl ::fidl_next::Wire for WireWritableWriteRequest<'static> {
    type Decoded<'de> = WireWritableWriteRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWritableWriteRequest<'static>
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, WireWritableWriteResponse> = 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(
        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(self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WritableWriteResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for WritableWriteResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireWritableWriteResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WritableWriteResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WritableWriteResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    WritableWriteResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireWritableWriteResponse> for WritableWriteResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireWritableWriteResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireWritableWriteResponse) -> Self {
        Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
    }
}

impl ::fidl_next::FromWireRef<WireWritableWriteResponse> for WritableWriteResponse {
    #[inline]
    fn from_wire_ref(wire: &WireWritableWriteResponse) -> Self {
        Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireWritableWriteResponse {
    type Decoded<'de> = 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, WritableServerHandler};

        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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireWritableWriteResponse,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        pub struct Write<T0> {
            data: T0,
        }

        impl<T0> ::fidl_next::Encodable for Write<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireWritableWriteRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.data, encoder, data)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Writable
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = WritableClientSender<___T>;
            type ServerSender = WritableServerSender<___T>;
        }

        /// The client sender for the `Writable` protocol.
        pub struct WritableClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> WritableClientSender<___T>
        where
            ___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"]
            pub fn write(
                &self,

                data: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Write, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.write_with(Write { data })
            }

            #[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"]
            pub fn write_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Write, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireWritableWriteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(7651971425397809026, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Writable` protocol.
        #[repr(transparent)]
        pub struct WritableServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> WritableServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Writable
where
    ___H: WritableClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

/// 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<Writable, ___T>,

        request: ::fidl_next::Request<writable::Write, ___T>,

        responder: ::fidl_next::Responder<writable::Write>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Writable
where
    ___H: WritableServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.write(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            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(
        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(self.origin, encoder, origin)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileSeekRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.origin, encoder, origin)?;

        ::fidl_next::EncodeRef::encode_ref(&self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileSeekRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileSeekRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileSeekRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileSeekRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileSeekRequest> for FileSeekRequest {
    #[inline]
    fn from_wire(wire: WireFileSeekRequest) -> Self {
        Self {
            origin: ::fidl_next::FromWire::from_wire(wire.origin),

            offset: ::fidl_next::FromWire::from_wire(wire.offset),
        }
    }
}

impl ::fidl_next::FromWireRef<WireFileSeekRequest> for FileSeekRequest {
    #[inline]
    fn from_wire_ref(wire: &WireFileSeekRequest) -> Self {
        Self {
            origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),

            offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireFileSeekRequest {
    type Decoded<'de> = 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, WireFileSeekResponse> = 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(
        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(self.offset_from_start, encoder, offset_from_start)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileSeekResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.offset_from_start, encoder, offset_from_start)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileSeekResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileSeekResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileSeekResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileSeekResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileSeekResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileSeekResponse> for FileSeekResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileSeekResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileSeekResponse) -> Self {
        Self { offset_from_start: ::fidl_next::FromWire::from_wire(wire.offset_from_start) }
    }
}

impl ::fidl_next::FromWireRef<WireFileSeekResponse> for FileSeekResponse {
    #[inline]
    fn from_wire_ref(wire: &WireFileSeekResponse) -> Self {
        Self { offset_from_start: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireFileSeekResponse {
    type Decoded<'de> = 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, WireFileReadAtRequest> = 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(
        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(self.count, encoder, count)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileReadAtRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.count, encoder, count)?;

        ::fidl_next::EncodeRef::encode_ref(&self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileReadAtRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileReadAtRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileReadAtRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileReadAtRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileReadAtRequest> for FileReadAtRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileReadAtRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileReadAtRequest) -> Self {
        Self {
            count: ::fidl_next::FromWire::from_wire(wire.count),

            offset: ::fidl_next::FromWire::from_wire(wire.offset),
        }
    }
}

impl ::fidl_next::FromWireRef<WireFileReadAtRequest> for FileReadAtRequest {
    #[inline]
    fn from_wire_ref(wire: &WireFileReadAtRequest) -> Self {
        Self {
            count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count),

            offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireFileReadAtRequest {
    type Decoded<'de> = 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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.data, encoder, data)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileReadAtResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.data, encoder, data)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileReadAtResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileReadAtResponse<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileReadAtResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileReadAtResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileReadAtResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireFileReadAtResponse<'de>> for FileReadAtResponse {
    #[inline]
    fn from_wire(wire: WireFileReadAtResponse<'de>) -> Self {
        Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireFileReadAtResponse<'de>> for FileReadAtResponse {
    #[inline]
    fn from_wire_ref(wire: &WireFileReadAtResponse<'de>) -> Self {
        Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
    }
}

/// The wire type corresponding to [`FileReadAtResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileReadAtResponse<'de> {
    pub data: ::fidl_next::WireVector<'de, u8>,
}

unsafe impl ::fidl_next::Wire for WireFileReadAtResponse<'static> {
    type Decoded<'de> = WireFileReadAtResponse<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileReadAtResponse<'static>
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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.data, encoder, data)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileWriteAtRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.data, encoder, data)?;

        ::fidl_next::EncodeRef::encode_ref(&self.offset, encoder, offset)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileWriteAtRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileWriteAtRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileWriteAtRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileWriteAtRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireFileWriteAtRequest<'de>> for FileWriteAtRequest {
    #[inline]
    fn from_wire(wire: WireFileWriteAtRequest<'de>) -> Self {
        Self {
            data: ::fidl_next::FromWire::from_wire(wire.data),

            offset: ::fidl_next::FromWire::from_wire(wire.offset),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireFileWriteAtRequest<'de>> for FileWriteAtRequest {
    #[inline]
    fn from_wire_ref(wire: &WireFileWriteAtRequest<'de>) -> Self {
        Self {
            data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data),

            offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
        }
    }
}

/// The wire type corresponding to [`FileWriteAtRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileWriteAtRequest<'de> {
    pub data: ::fidl_next::WireVector<'de, u8>,

    pub offset: ::fidl_next::WireU64,
}

unsafe impl ::fidl_next::Wire for WireFileWriteAtRequest<'static> {
    type Decoded<'de> = WireFileWriteAtRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileWriteAtRequest<'static>
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, WireFileWriteAtResponse> = 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(
        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(self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileWriteAtResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.actual_count, encoder, actual_count)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileWriteAtResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileWriteAtResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileWriteAtResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileWriteAtResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileWriteAtResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileWriteAtResponse> for FileWriteAtResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileWriteAtResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileWriteAtResponse) -> Self {
        Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
    }
}

impl ::fidl_next::FromWireRef<WireFileWriteAtResponse> for FileWriteAtResponse {
    #[inline]
    fn from_wire_ref(wire: &WireFileWriteAtResponse) -> Self {
        Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireFileWriteAtResponse {
    type Decoded<'de> = 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, WireFileResizeRequest> = 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(
        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(self.length, encoder, length)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileResizeRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.length, encoder, length)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileResizeRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileResizeRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileResizeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileResizeRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileResizeRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileResizeRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileResizeRequest> for FileResizeRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileResizeRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileResizeRequest) -> Self {
        Self { length: ::fidl_next::FromWire::from_wire(wire.length) }
    }
}

impl ::fidl_next::FromWireRef<WireFileResizeRequest> for FileResizeRequest {
    #[inline]
    fn from_wire_ref(wire: &WireFileResizeRequest) -> Self {
        Self { length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireFileResizeRequest {
    type Decoded<'de> = 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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for VmoFlags
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireVmoFlags> for VmoFlags {
    #[inline]
    fn from_wire(wire: WireVmoFlags) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireVmoFlags> for VmoFlags {
    #[inline]
    fn from_wire_ref(wire: &WireVmoFlags) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireVmoFlags {
    type Decoded<'de> = Self;

    #[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, WireFileGetBackingMemoryRequest> = 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(
        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(self.flags, encoder, flags)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileGetBackingMemoryRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.flags, encoder, flags)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileGetBackingMemoryRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileGetBackingMemoryRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileGetBackingMemoryRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileGetBackingMemoryRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FileGetBackingMemoryRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileGetBackingMemoryRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFileGetBackingMemoryRequest> for FileGetBackingMemoryRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileGetBackingMemoryRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    crate::VmoFlags as ::fidl_next::FromWire<crate::WireVmoFlags>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireFileGetBackingMemoryRequest) -> Self {
        Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
    }
}

impl ::fidl_next::FromWireRef<WireFileGetBackingMemoryRequest> for FileGetBackingMemoryRequest {
    #[inline]
    fn from_wire_ref(wire: &WireFileGetBackingMemoryRequest) -> Self {
        Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
    }
}

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

unsafe impl ::fidl_next::Wire for WireFileGetBackingMemoryRequest {
    type Decoded<'de> = 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, WireFileGetBackingMemoryResponse> = 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(
        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(self.vmo, encoder, vmo)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileGetBackingMemoryResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileGetBackingMemoryResponse>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileGetBackingMemoryResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileGetBackingMemoryResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireFileGetBackingMemoryResponse> for FileGetBackingMemoryResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileGetBackingMemoryResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireHandle,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileGetBackingMemoryResponse) -> Self {
        Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
    }
}

/// The wire type corresponding to [`FileGetBackingMemoryResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileGetBackingMemoryResponse {
    pub vmo: ::fidl_next::fuchsia::WireHandle,
}

unsafe impl ::fidl_next::Wire for WireFileGetBackingMemoryResponse {
    type Decoded<'de> = 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<'static>;
}

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(
        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(self.dst_parent_token, encoder, dst_parent_token)?;

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for LinkableLinkIntoRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireLinkableLinkIntoRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LinkableLinkIntoRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LinkableLinkIntoRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireLinkableLinkIntoRequest<'de>> for LinkableLinkIntoRequest {
    #[inline]
    fn from_wire(wire: WireLinkableLinkIntoRequest<'de>) -> Self {
        Self {
            dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),

            dst: ::fidl_next::FromWire::from_wire(wire.dst),
        }
    }
}

/// The wire type corresponding to [`LinkableLinkIntoRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLinkableLinkIntoRequest<'de> {
    pub dst_parent_token: ::fidl_next::fuchsia::WireHandle,

    pub dst: ::fidl_next::WireString<'de>,
}

unsafe impl ::fidl_next::Wire for WireLinkableLinkIntoRequest<'static> {
    type Decoded<'de> = WireLinkableLinkIntoRequest<'de>;

    #[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<'static>
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, LinkableServerHandler};

        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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireLinkableLinkIntoResponse,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        pub struct LinkInto<T0, T1> {
            dst_parent_token: T0,

            dst: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for LinkInto<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireLinkableLinkIntoRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                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(self.dst_parent_token, encoder, dst_parent_token)?;

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Linkable
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = LinkableClientSender<___T>;
            type ServerSender = LinkableServerSender<___T>;
        }

        /// The client sender for the `Linkable` protocol.
        pub struct LinkableClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> LinkableClientSender<___T>
        where
            ___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"]
            pub fn link_into(
                &self,

                dst_parent_token: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,

                dst: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.link_into_with(LinkInto { dst_parent_token, dst })
            }

            #[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"]
            pub fn link_into_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireLinkableLinkIntoRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(6121399674497678964, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Linkable` protocol.
        #[repr(transparent)]
        pub struct LinkableServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> LinkableServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

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

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Linkable
where
    ___H: LinkableClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

/// 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<Linkable, ___T>,

        request: ::fidl_next::Request<linkable::LinkInto, ___T>,

        responder: ::fidl_next::Responder<linkable::LinkInto>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Linkable
where
    ___H: LinkableServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.link_into(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            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(
        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(self.offset, encoder, offset)?;

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileAllocateRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileAllocateRequest>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileAllocateRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileAllocateRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireFileAllocateRequest> for FileAllocateRequest {
    #[inline]
    fn from_wire(wire: WireFileAllocateRequest) -> Self {
        Self {
            offset: ::fidl_next::FromWire::from_wire(wire.offset),

            length: ::fidl_next::FromWire::from_wire(wire.length),

            mode: ::fidl_next::FromWire::from_wire(wire.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::Wire for WireFileAllocateRequest {
    type Decoded<'de> = 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<'static>;
}

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(
        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(self.options, encoder, options)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileEnableVerityRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileEnableVerityRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileEnableVerityRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileEnableVerityRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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<'de> ::fidl_next::FromWire<WireFileEnableVerityRequest<'de>> for FileEnableVerityRequest {
    #[inline]
    fn from_wire(wire: WireFileEnableVerityRequest<'de>) -> Self {
        Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
    }
}

/// The wire type corresponding to [`FileEnableVerityRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireFileEnableVerityRequest<'de> {
    pub options: crate::WireVerificationOptions<'de>,
}

unsafe impl ::fidl_next::Wire for WireFileEnableVerityRequest<'static> {
    type Decoded<'de> = WireFileEnableVerityRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFileEnableVerityRequest<'static>
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 = "fuchsia.io.File";
}

pub mod file {
    pub mod prelude {
        pub use crate::{file, File, FileClientHandler, FileServerHandler};

        pub use crate::AdvisoryLockingAdvisoryLockRequest;

        pub use crate::AdvisoryLockingAdvisoryLockResponse;

        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::NodeDeprecatedGetAttrResponse;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetAttrRequest;

        pub use crate::NodeDeprecatedSetAttrResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        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::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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<
            'static,
            ::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<'static>;
    }

    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<'static>;
    }

    pub struct DeprecatedGetAttr;

    impl ::fidl_next::Method for DeprecatedGetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::File;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetAttrResponse;
    }

    pub struct DeprecatedSetAttr;

    impl ::fidl_next::Method for DeprecatedSetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::File;

        type Request = crate::WireNodeDeprecatedSetAttrRequest;

        type Response = crate::WireNodeDeprecatedSetAttrResponse;
    }

    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<
            'static,
            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<
            'static,
            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<'static>;
    }

    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<'static>;
    }

    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<
            'static,
            crate::WireNodeAttributes2<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::File;

        type Request = crate::WireMutableNodeAttributes<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static, 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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireExtendedAttributeValue<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::File;

        type Request = crate::WireNodeSetExtendedAttributeRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<
            'static,
            crate::WireReadableReadResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Write;

    impl ::fidl_next::Method for Write {
        const ORDINAL: u64 = 7651971425397809026;

        type Protocol = crate::File;

        type Request = crate::WireWritableWriteRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;
    }

    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<'static, 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<
            'static,
            crate::WireFileReadAtResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct WriteAt;

    impl ::fidl_next::Method for WriteAt {
        const ORDINAL: u64 = 8736683935131400491;

        type Protocol = crate::File;

        type Request = crate::WireFileWriteAtRequest<'static>;

        type Response =
            ::fidl_next::WireResult<'static, 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<'static, 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<
            'static,
            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<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireFileEnableVerityResponse,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        pub struct AdvisoryLock<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for AdvisoryLock<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            type Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireAdvisoryLockRequest<'static>>,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct LinkInto<T0, T1> {
            dst_parent_token: T0,

            dst: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for LinkInto<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireLinkableLinkIntoRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                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(self.dst_parent_token, encoder, dst_parent_token)?;

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

                Ok(())
            }
        }

        pub struct Clone<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for Clone<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct DeprecatedClone<T0, T1> {
            flags: T0,

            object: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedClone<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            type Encoded = crate::WireNodeDeprecatedCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct OnOpen<T0, T1> {
            s: T0,

            info: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for OnOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            type Encoded = crate::WireNodeOnOpenRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            #[inline]
            fn encode(
                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(self.s, encoder, s)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetAttr<T0, T1> {
            flags: T0,

            attributes: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedSetAttr<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributes>,
        {
            type Encoded = crate::WireNodeDeprecatedSetAttrRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributes>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for DeprecatedSetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,
        {
            type Encoded = crate::WireNodeDeprecatedSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct SetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for SetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireFlags>,
        {
            type Encoded = crate::WireNodeSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct GetAttributes<T0> {
            query: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetAttributes<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributesQuery>,
        {
            type Encoded = crate::WireNodeGetAttributesRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributesQuery>,
        {
            #[inline]
            fn encode(
                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(self.query, encoder, query)?;

                Ok(())
            }
        }

        pub struct ListExtendedAttributes<T0> {
            iterator: T0,
        }

        impl<T0> ::fidl_next::Encodable for ListExtendedAttributes<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireNodeListExtendedAttributesRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.iterator, encoder, iterator)?;

                Ok(())
            }
        }

        pub struct GetExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct SetExtendedAttribute<T0, T1, T2> {
            name: T0,

            value: T1,

            mode: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for SetExtendedAttribute<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireSetExtendedAttributeMode>,
        {
            type Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for SetExtendedAttribute<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireSetExtendedAttributeMode>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

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

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

                Ok(())
            }
        }

        pub struct RemoveExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for RemoveExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct Read<T0> {
            count: T0,
        }

        impl<T0> ::fidl_next::Encodable for Read<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireReadableReadRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.count, encoder, count)?;

                Ok(())
            }
        }

        pub struct Write<T0> {
            data: T0,
        }

        impl<T0> ::fidl_next::Encodable for Write<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireWritableWriteRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.data, encoder, data)?;

                Ok(())
            }
        }

        pub struct Seek<T0, T1> {
            origin: T0,

            offset: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Seek<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireSeekOrigin>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireI64>,
        {
            type Encoded = crate::WireFileSeekRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireSeekOrigin>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireI64>,
        {
            #[inline]
            fn encode(
                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(self.origin, encoder, origin)?;

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

                Ok(())
            }
        }

        pub struct ReadAt<T0, T1> {
            count: T0,

            offset: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for ReadAt<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireFileReadAtRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.count, encoder, count)?;

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

                Ok(())
            }
        }

        pub struct WriteAt<T0, T1> {
            data: T0,

            offset: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for WriteAt<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireFileWriteAtRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.data, encoder, data)?;

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

                Ok(())
            }
        }

        pub struct Resize<T0> {
            length: T0,
        }

        impl<T0> ::fidl_next::Encodable for Resize<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireFileResizeRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
        {
            #[inline]
            fn encode(
                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(self.length, encoder, length)?;

                Ok(())
            }
        }

        pub struct GetBackingMemory<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetBackingMemory<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireVmoFlags>,
        {
            type Encoded = crate::WireFileGetBackingMemoryRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireVmoFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct Allocate<T0, T1, T2> {
            offset: T0,

            length: T1,

            mode: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for Allocate<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireAllocateMode>,
        {
            type Encoded = crate::WireFileAllocateRequest;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for Allocate<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireAllocateMode>,
        {
            #[inline]
            fn encode(
                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(self.offset, encoder, offset)?;

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

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

                Ok(())
            }
        }

        pub struct EnableVerity<T0> {
            options: T0,
        }

        impl<T0> ::fidl_next::Encodable for EnableVerity<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireVerificationOptions<'static>>,
        {
            type Encoded = crate::WireFileEnableVerityRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireVerificationOptions<'static>>,
        {
            #[inline]
            fn encode(
                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(self.options, encoder, options)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::File
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = FileClientSender<___T>;
            type ServerSender = FileServerSender<___T>;
        }

        /// The client sender for the `File` protocol.
        pub struct FileClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> FileClientSender<___T>
        where
            ___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"]
            pub fn advisory_lock(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockRequest<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.advisory_lock_with(AdvisoryLock { request })
            }

            #[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"]
            pub fn advisory_lock_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::AdvisoryLock, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAdvisoryLockingAdvisoryLockRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn link_into(
                &self,

                dst_parent_token: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,

                dst: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.link_into_with(LinkInto { dst_parent_token, dst })
            }

            #[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"]
            pub fn link_into_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireLinkableLinkIntoRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(6121399674497678964, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn clone(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_unknown::Cloneable,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.clone_with(Clone { request })
            }

            pub fn clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
                >,
            {
                self.sender.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"]
            pub fn close(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Close, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(6540867515453498750, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn query(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Query, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(2763219980499352582, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Node,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.deprecated_clone_with(DeprecatedClone { flags, object })
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedCloneRequest,
                >,
            {
                self.sender.send_one_way(6512600400724287855, request)
            }

            #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
            pub fn deprecated_get_attr(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetAttr, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8689798978500614909, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributeFlags,
                >,

                attributes: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributes,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_attr_with(DeprecatedSetAttr { flags, attributes })
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetAttrRequest,
                >,
            {
                self.sender
                    .send_two_way(4721673413776871238, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
            pub fn deprecated_get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(6595803110182632097, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_flags_with(DeprecatedSetFlags { flags })
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(105530239381466147, ())
                    .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"]
            pub fn set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.set_flags_with(SetFlags { flags })
            }

            #[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"]
            pub fn set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetFlagsRequest,
                >,
            {
                self.sender
                    .send_two_way(6172186066099445416, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " Query the filesystem for filesystem-specific information.\n"]
            pub fn query_filesystem(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::QueryFilesystem, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8013111122914313744, ())
                    .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"]
            pub fn get_attributes(
                &self,

                query: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributesQuery,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_attributes_with(GetAttributes { query })
            }

            #[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"]
            pub fn get_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetAttributesRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn update_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::UpdateAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireMutableNodeAttributes<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn sync(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Sync, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(3196473584242777161, ())
                    .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"]
            pub fn list_extended_attributes(
                &self,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::ExtendedAttributeIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.list_extended_attributes_with(ListExtendedAttributes { iterator })
            }

            #[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"]
            pub fn list_extended_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeListExtendedAttributesRequest,
                >,
            {
                self.sender.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"]
            pub fn get_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.get_extended_attribute_with(GetExtendedAttribute { name })
            }

            #[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"]
            pub fn get_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn set_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                value: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireExtendedAttributeValue<'static>,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireSetExtendedAttributeMode,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.set_extended_attribute_with(SetExtendedAttribute { name, value, mode })
            }

            #[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"]
            pub fn set_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn remove_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.remove_extended_attribute_with(RemoveExtendedAttribute { name })
            }

            #[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"]
            pub fn remove_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn read(
                &self,

                count: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Read, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.read_with(Read { count })
            }

            #[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"]
            pub fn read_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Read, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireReadableReadRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn write(
                &self,

                data: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Write, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.write_with(Write { data })
            }

            #[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"]
            pub fn write_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Write, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireWritableWriteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(7651971425397809026, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn describe(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Describe, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(7545125870053689020, ())
                    .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"]
            pub fn seek(
                &self,

                origin: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireSeekOrigin,
                >,

                offset: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireI64,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Seek, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.seek_with(Seek { origin, offset })
            }

            #[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"]
            pub fn seek_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Seek, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileSeekRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn read_at(
                &self,

                count: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                offset: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ReadAt, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.read_at_with(ReadAt { count, offset })
            }

            #[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"]
            pub fn read_at_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ReadAt, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileReadAtRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn write_at(
                &self,

                data: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                offset: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::WriteAt, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.write_at_with(WriteAt { data, offset })
            }

            #[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"]
            pub fn write_at_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::WriteAt, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileWriteAtRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn resize(
                &self,

                length: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Resize, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.resize_with(Resize { length })
            }

            #[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"]
            pub fn resize_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Resize, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileResizeRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn get_backing_memory(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireVmoFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetBackingMemory, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_backing_memory_with(GetBackingMemory { flags })
            }

            #[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"]
            pub fn get_backing_memory_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetBackingMemory, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileGetBackingMemoryRequest,
                >,
            {
                self.sender
                    .send_two_way(46911652864194091, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " Pre-allocate on-disk space for this file.\n"]
            pub fn allocate(
                &self,

                offset: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                length: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireAllocateMode,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Allocate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.allocate_with(Allocate { offset, length, mode })
            }

            #[doc = " Pre-allocate on-disk space for this file.\n"]
            pub fn allocate_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Allocate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileAllocateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn enable_verity(
                &self,

                options: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireVerificationOptions<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::EnableVerity, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.enable_verity_with(EnableVerity { options })
            }

            #[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"]
            pub fn enable_verity_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::EnableVerity, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFileEnableVerityRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(3189145313204943035, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `File` protocol.
        #[repr(transparent)]
        pub struct FileServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> FileServerSender<___T>
        where
            ___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"]
            pub fn on_open(
                &self,

                s: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireI32,
                >,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOptionalNodeInfoDeprecated<'static>,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.on_open_with(OnOpen { s, info })
            }

            #[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"]

            pub fn on_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnOpen as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.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"]

            pub fn on_representation_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnRepresentation as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(6679970090861613324, request)
            }
        }
    }
}

/// 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<File, ___T>,

        event: ::fidl_next::Response<file::OnOpen, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        event: ::fidl_next::Response<file::OnRepresentation, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<File, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for File
where
    ___H: FileClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <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::DeprecatedGetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedSetAttr 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::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>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_representation(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// 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<File, ___T>,

        request: ::fidl_next::Request<file::AdvisoryLock, ___T>,

        responder: ::fidl_next::Responder<file::AdvisoryLock>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::LinkInto, ___T>,

        responder: ::fidl_next::Responder<file::LinkInto>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        request: ::fidl_next::Request<file::Clone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        responder: ::fidl_next::Responder<file::Close>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        responder: ::fidl_next::Responder<file::Query>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        request: ::fidl_next::Request<file::DeprecatedClone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
    fn deprecated_get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        responder: ::fidl_next::Responder<file::DeprecatedGetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
    fn deprecated_set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,

        responder: ::fidl_next::Responder<file::DeprecatedSetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        responder: ::fidl_next::Responder<file::DeprecatedGetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,

        responder: ::fidl_next::Responder<file::DeprecatedSetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        responder: ::fidl_next::Responder<file::GetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::SetFlags, ___T>,

        responder: ::fidl_next::Responder<file::SetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        responder: ::fidl_next::Responder<file::QueryFilesystem>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::GetAttributes, ___T>,

        responder: ::fidl_next::Responder<file::GetAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::UpdateAttributes, ___T>,

        responder: ::fidl_next::Responder<file::UpdateAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        responder: ::fidl_next::Responder<file::Sync>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<file::GetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<file::SetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<file::RemoveExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::Read, ___T>,

        responder: ::fidl_next::Responder<file::Read>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::Write, ___T>,

        responder: ::fidl_next::Responder<file::Write>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn describe(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        responder: ::fidl_next::Responder<file::Describe>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::Seek, ___T>,

        responder: ::fidl_next::Responder<file::Seek>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::ReadAt, ___T>,

        responder: ::fidl_next::Responder<file::ReadAt>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::WriteAt, ___T>,

        responder: ::fidl_next::Responder<file::WriteAt>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::Resize, ___T>,

        responder: ::fidl_next::Responder<file::Resize>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::GetBackingMemory, ___T>,

        responder: ::fidl_next::Responder<file::GetBackingMemory>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Pre-allocate on-disk space for this file.\n"]
    fn allocate(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,

        request: ::fidl_next::Request<file::Allocate, ___T>,

        responder: ::fidl_next::Responder<file::Allocate>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<File, ___T>,

        request: ::fidl_next::Request<file::EnableVerity, ___T>,

        responder: ::fidl_next::Responder<file::EnableVerity>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<File, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for File
where
    ___H: FileServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <file::AdvisoryLock as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::LinkInto as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Clone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedClone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedSetAttr as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::DeprecatedSetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::SetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::UpdateAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::ListExtendedAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::SetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Read as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Write as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Seek as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::ReadAt as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::WriteAt as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Resize as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::GetBackingMemory as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::Allocate as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <file::EnableVerity as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.deprecated_clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.list_extended_attributes(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.advisory_lock(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6121399674497678964 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.link_into(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder).await;
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder).await;
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_attr(sender, responder).await;
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_attr(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder).await;
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder).await;
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder).await;
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.update_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder).await;
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.remove_extended_attribute(sender, decoded, responder).await
                    }
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            395825947633028830 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.read(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            7651971425397809026 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.write(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            7545125870053689020 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.describe(sender, responder).await;
            }

            8649041485622956551 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.seek(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            1587416148701180478 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.read_at(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8736683935131400491 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.write_at(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3134648685270758458 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.resize(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            46911652864194091 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_backing_memory(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8645235848064269614 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.allocate(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3189145313204943035 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.enable_verity(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[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, WireFileObject> = 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(
        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(self.event, encoder, event)?;

        ::fidl_next::Encode::encode(self.stream, encoder, stream)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FileObject {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFileObject>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FileObject
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FileObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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::FromWire<WireFileObject> for FileObject {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFileObject, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireOptionalHandle,
            >>::COPY_OPTIMIZATION
                .is_enabled()
                && <Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::FromWire<
                    ::fidl_next::fuchsia::WireOptionalHandle,
                >>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFileObject) -> Self {
        Self {
            event: ::fidl_next::FromWire::from_wire(wire.event),

            stream: ::fidl_next::FromWire::from_wire(wire.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::Wire for WireFileObject {
    type Decoded<'de> = 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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FileSignal
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::FromWire<WireFileSignal> for FileSignal {
    #[inline]
    fn from_wire(wire: WireFileSignal) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireFileSignal> for FileSignal {
    #[inline]
    fn from_wire_ref(wire: &WireFileSignal) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireFileSignal {
    type Decoded<'de> = Self;

    #[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, WireFilesystemInfo> = 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(
        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(self.total_bytes, encoder, total_bytes)?;

        ::fidl_next::Encode::encode(self.used_bytes, encoder, used_bytes)?;

        ::fidl_next::Encode::encode(self.total_nodes, encoder, total_nodes)?;

        ::fidl_next::Encode::encode(self.used_nodes, encoder, used_nodes)?;

        ::fidl_next::Encode::encode(self.free_shared_pool_bytes, encoder, free_shared_pool_bytes)?;

        ::fidl_next::Encode::encode(self.fs_id, encoder, fs_id)?;

        ::fidl_next::Encode::encode(self.block_size, encoder, block_size)?;

        ::fidl_next::Encode::encode(self.max_filename_size, encoder, max_filename_size)?;

        ::fidl_next::Encode::encode(self.fs_type, encoder, fs_type)?;

        ::fidl_next::Encode::encode(self.padding, encoder, padding)?;

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for FilesystemInfo
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.total_bytes, encoder, total_bytes)?;

        ::fidl_next::EncodeRef::encode_ref(&self.used_bytes, encoder, used_bytes)?;

        ::fidl_next::EncodeRef::encode_ref(&self.total_nodes, encoder, total_nodes)?;

        ::fidl_next::EncodeRef::encode_ref(&self.used_nodes, encoder, used_nodes)?;

        ::fidl_next::EncodeRef::encode_ref(
            &self.free_shared_pool_bytes,
            encoder,
            free_shared_pool_bytes,
        )?;

        ::fidl_next::EncodeRef::encode_ref(&self.fs_id, encoder, fs_id)?;

        ::fidl_next::EncodeRef::encode_ref(&self.block_size, encoder, block_size)?;

        ::fidl_next::EncodeRef::encode_ref(&self.max_filename_size, encoder, max_filename_size)?;

        ::fidl_next::EncodeRef::encode_ref(&self.fs_type, encoder, fs_type)?;

        ::fidl_next::EncodeRef::encode_ref(&self.padding, encoder, padding)?;

        ::fidl_next::EncodeRef::encode_ref(&self.name, encoder, name)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for FilesystemInfo {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFilesystemInfo>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FilesystemInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FilesystemInfo: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for FilesystemInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FilesystemInfo: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireFilesystemInfo> for FilesystemInfo {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFilesystemInfo, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                    .is_enabled()
                && <[i8; 32] as ::fidl_next::FromWire<[i8; 32]>>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireFilesystemInfo) -> Self {
        Self {
            total_bytes: ::fidl_next::FromWire::from_wire(wire.total_bytes),

            used_bytes: ::fidl_next::FromWire::from_wire(wire.used_bytes),

            total_nodes: ::fidl_next::FromWire::from_wire(wire.total_nodes),

            used_nodes: ::fidl_next::FromWire::from_wire(wire.used_nodes),

            free_shared_pool_bytes: ::fidl_next::FromWire::from_wire(wire.free_shared_pool_bytes),

            fs_id: ::fidl_next::FromWire::from_wire(wire.fs_id),

            block_size: ::fidl_next::FromWire::from_wire(wire.block_size),

            max_filename_size: ::fidl_next::FromWire::from_wire(wire.max_filename_size),

            fs_type: ::fidl_next::FromWire::from_wire(wire.fs_type),

            padding: ::fidl_next::FromWire::from_wire(wire.padding),

            name: ::fidl_next::FromWire::from_wire(wire.name),
        }
    }
}

impl ::fidl_next::FromWireRef<WireFilesystemInfo> for FilesystemInfo {
    #[inline]
    fn from_wire_ref(wire: &WireFilesystemInfo) -> Self {
        Self {
            total_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_bytes),

            used_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_bytes),

            total_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_nodes),

            used_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_nodes),

            free_shared_pool_bytes: ::fidl_next::FromWireRef::from_wire_ref(
                &wire.free_shared_pool_bytes,
            ),

            fs_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_id),

            block_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.block_size),

            max_filename_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_filename_size),

            fs_type: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_type),

            padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),

            name: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireFilesystemInfo {
    type Decoded<'de> = 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;

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, WireService> =
        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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Service
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &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 Service {
    type EncodedOption = ::fidl_next::WireBox<'static, WireService>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Service
where
    ___E: ::fidl_next::Encoder + ?Sized,
    Service: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Service
where
    ___E: ::fidl_next::Encoder + ?Sized,
    Service: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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::FromWire<WireService> for Service {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireService, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

    #[inline]
    fn from_wire(wire: WireService) -> Self {
        Self {}
    }
}

impl ::fidl_next::FromWireRef<WireService> for Service {
    #[inline]
    fn from_wire_ref(wire: &WireService) -> Self {
        Self {}
    }
}

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

unsafe impl ::fidl_next::Wire for WireService {
    type Decoded<'de> = 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<'static>;
}

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

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        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(self.target, encoder, target)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for SymlinkObject
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &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::EncodeRef::encode_ref(&self.target, encoder, target)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for SymlinkObject {
    type EncodedOption = ::fidl_next::WireBox<'static, WireSymlinkObject<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for SymlinkObject
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SymlinkObject: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for SymlinkObject
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SymlinkObject: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&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<'de> ::fidl_next::FromWire<WireSymlinkObject<'de>> for SymlinkObject {
    #[inline]
    fn from_wire(wire: WireSymlinkObject<'de>) -> Self {
        Self { target: ::fidl_next::FromWire::from_wire(wire.target) }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireSymlinkObject<'de>> for SymlinkObject {
    #[inline]
    fn from_wire_ref(wire: &WireSymlinkObject<'de>) -> Self {
        Self { target: ::fidl_next::FromWireRef::from_wire_ref(&wire.target) }
    }
}

/// The wire type corresponding to [`SymlinkObject`].
#[derive(Debug)]
#[repr(C)]
pub struct WireSymlinkObject<'de> {
    pub target: ::fidl_next::WireVector<'de, u8>,
}

unsafe impl ::fidl_next::Wire for WireSymlinkObject<'static> {
    type Decoded<'de> = WireSymlinkObject<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireSymlinkObject<'static>
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<'static>;
}

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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeInfoDeprecated { raw, _phantom: _ } = 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 NodeInfoDeprecated {
    type EncodedOption = WireOptionalNodeInfoDeprecated<'static>;
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNodeInfoDeprecated<'de>> for NodeInfoDeprecated {
    #[inline]
    fn from_wire(wire: WireNodeInfoDeprecated<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireService>()
            })),

            2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireFileObject>()
            })),

            3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirectoryObject>()
            })),

            4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireSymlinkObject<'de>>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalNodeInfoDeprecated<'de>>
    for Box<NodeInfoDeprecated>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalNodeInfoDeprecated<'de>) -> Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(Box::new(::fidl_next::FromWire::from_wire(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`NodeInfoDeprecated`].
#[repr(transparent)]
pub struct WireNodeInfoDeprecated<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireNodeInfoDeprecated<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireService>() };
            }

            2 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireFileObject>() };
            }

            3 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirectoryObject>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireSymlinkObject<'de>>() };
            }

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

unsafe impl ::fidl_next::Wire for WireNodeInfoDeprecated<'static> {
    type Decoded<'de> = WireNodeInfoDeprecated<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod node_info_deprecated {
    pub enum Ref<'de> {
        Service(&'de crate::WireService),

        File(&'de crate::WireFileObject),

        Directory(&'de crate::WireDirectoryObject),

        Symlink(&'de crate::WireSymlinkObject<'de>),
    }
}

impl<'de> WireNodeInfoDeprecated<'de> {
    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<'static>
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, _phantom: _ } = 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<'static>>(
                raw, decoder,
            )?,

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireNodeInfoDeprecated<'de> {
    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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalNodeInfoDeprecated<'static> {
    type Decoded<'de> = WireOptionalNodeInfoDeprecated<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalNodeInfoDeprecated<'de> {
    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<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireNodeInfoDeprecated<'de>> {
        if self.is_some() {
            Some(WireNodeInfoDeprecated { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalNodeInfoDeprecated<'static>
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, _phantom: _ } = 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<'static>>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalNodeInfoDeprecated<'de> {
    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 = "fuchsia.io.Symlink";
}

pub mod symlink {
    pub mod prelude {
        pub use crate::{symlink, Symlink, SymlinkClientHandler, SymlinkServerHandler};

        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::NodeDeprecatedGetAttrResponse;

        pub use crate::NodeDeprecatedGetFlagsResponse;

        pub use crate::NodeDeprecatedSetAttrRequest;

        pub use crate::NodeDeprecatedSetAttrResponse;

        pub use crate::NodeDeprecatedSetFlagsRequest;

        pub use crate::NodeDeprecatedSetFlagsResponse;

        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::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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<
            'static,
            ::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<'static>;
    }

    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<'static>;
    }

    pub struct DeprecatedGetAttr;

    impl ::fidl_next::Method for DeprecatedGetAttr {
        const ORDINAL: u64 = 8689798978500614909;

        type Protocol = crate::Symlink;

        type Request = ();

        type Response = crate::WireNodeDeprecatedGetAttrResponse;
    }

    pub struct DeprecatedSetAttr;

    impl ::fidl_next::Method for DeprecatedSetAttr {
        const ORDINAL: u64 = 4721673413776871238;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeDeprecatedSetAttrRequest;

        type Response = crate::WireNodeDeprecatedSetAttrResponse;
    }

    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<
            'static,
            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<
            'static,
            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<'static>;
    }

    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<'static>;
    }

    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<
            'static,
            crate::WireNodeAttributes2<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct UpdateAttributes;

    impl ::fidl_next::Method for UpdateAttributes {
        const ORDINAL: u64 = 3677402239314018056;

        type Protocol = crate::Symlink;

        type Request = crate::WireMutableNodeAttributes<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static, 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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireExtendedAttributeValue<'static>,
            ::fidl_next::WireI32,
        >;
    }

    pub struct SetExtendedAttribute;

    impl ::fidl_next::Method for SetExtendedAttribute {
        const ORDINAL: u64 = 5374223046099989052;

        type Protocol = crate::Symlink;

        type Request = crate::WireNodeSetExtendedAttributeRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            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<'static, crate::WireSymlinkInfo<'static>>;
    }

    mod ___detail {

        pub struct LinkInto<T0, T1> {
            dst_parent_token: T0,

            dst: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for LinkInto<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireLinkableLinkIntoRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireHandle>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                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(self.dst_parent_token, encoder, dst_parent_token)?;

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

                Ok(())
            }
        }

        pub struct Clone<T0> {
            request: T0,
        }

        impl<T0> ::fidl_next::Encodable for Clone<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_unknown::Cloneable,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.request, encoder, request)?;

                Ok(())
            }
        }

        pub struct DeprecatedClone<T0, T1> {
            flags: T0,

            object: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedClone<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            type Encoded = crate::WireNodeDeprecatedCloneRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,

            T1: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::WireChannel>,
            >,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct OnOpen<T0, T1> {
            s: T0,

            info: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for OnOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            type Encoded = crate::WireNodeOnOpenRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireI32>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireOptionalNodeInfoDeprecated<'static>>,
        {
            #[inline]
            fn encode(
                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(self.s, encoder, s)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetAttr<T0, T1> {
            flags: T0,

            attributes: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DeprecatedSetAttr<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributes>,
        {
            type Encoded = crate::WireNodeDeprecatedSetAttrRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributeFlags>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributes>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

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

                Ok(())
            }
        }

        pub struct DeprecatedSetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for DeprecatedSetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireOpenFlags>,
        {
            type Encoded = crate::WireNodeDeprecatedSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireOpenFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct SetFlags<T0> {
            flags: T0,
        }

        impl<T0> ::fidl_next::Encodable for SetFlags<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireFlags>,
        {
            type Encoded = crate::WireNodeSetFlagsRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireFlags>,
        {
            #[inline]
            fn encode(
                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(self.flags, encoder, flags)?;

                Ok(())
            }
        }

        pub struct GetAttributes<T0> {
            query: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetAttributes<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireNodeAttributesQuery>,
        {
            type Encoded = crate::WireNodeGetAttributesRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireNodeAttributesQuery>,
        {
            #[inline]
            fn encode(
                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(self.query, encoder, query)?;

                Ok(())
            }
        }

        pub struct ListExtendedAttributes<T0> {
            iterator: T0,
        }

        impl<T0> ::fidl_next::Encodable for ListExtendedAttributes<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireNodeListExtendedAttributesRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::ExtendedAttributeIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                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(self.iterator, encoder, iterator)?;

                Ok(())
            }
        }

        pub struct GetExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for GetExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        pub struct SetExtendedAttribute<T0, T1, T2> {
            name: T0,

            value: T1,

            mode: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for SetExtendedAttribute<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encodable<Encoded = crate::WireSetExtendedAttributeMode>,
        {
            type Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>;
        }

        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for SetExtendedAttribute<T0, T1, T2>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireExtendedAttributeValue<'static>>,

            T2: ::fidl_next::Encode<___E, Encoded = crate::WireSetExtendedAttributeMode>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

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

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

                Ok(())
            }
        }

        pub struct RemoveExtendedAttribute<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for RemoveExtendedAttribute<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            type Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireVector<'static, u8>>,
        {
            #[inline]
            fn encode(
                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(self.name, encoder, name)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Symlink
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = SymlinkClientSender<___T>;
            type ServerSender = SymlinkServerSender<___T>;
        }

        /// The client sender for the `Symlink` protocol.
        pub struct SymlinkClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> SymlinkClientSender<___T>
        where
            ___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"]
            pub fn link_into(
                &self,

                dst_parent_token: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,

                dst: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.link_into_with(LinkInto { dst_parent_token, dst })
            }

            #[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"]
            pub fn link_into_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::LinkInto, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireLinkableLinkIntoRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(6121399674497678964, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn clone(
                &self,

                request: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_unknown::Cloneable,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.clone_with(Clone { request })
            }

            pub fn clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next_fuchsia_unknown::WireCloneableCloneRequest,
                >,
            {
                self.sender.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"]
            pub fn close(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Close, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(6540867515453498750, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn query(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Query, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(2763219980499352582, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,

                object: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::Node,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.deprecated_clone_with(DeprecatedClone { flags, object })
            }

            #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
            pub fn deprecated_clone_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedCloneRequest,
                >,
            {
                self.sender.send_one_way(6512600400724287855, request)
            }

            #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
            pub fn deprecated_get_attr(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetAttr, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8689798978500614909, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributeFlags,
                >,

                attributes: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributes,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_attr_with(DeprecatedSetAttr { flags, attributes })
            }

            #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
            pub fn deprecated_set_attr_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetAttr, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetAttrRequest,
                >,
            {
                self.sender
                    .send_two_way(4721673413776871238, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
            pub fn deprecated_get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedGetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(6595803110182632097, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOpenFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.deprecated_set_flags_with(DeprecatedSetFlags { flags })
            }

            #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
            pub fn deprecated_set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DeprecatedSetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeDeprecatedSetFlagsRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn get_flags(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetFlags, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(105530239381466147, ())
                    .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"]
            pub fn set_flags(
                &self,

                flags: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireFlags,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.set_flags_with(SetFlags { flags })
            }

            #[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"]
            pub fn set_flags_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetFlags, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetFlagsRequest,
                >,
            {
                self.sender
                    .send_two_way(6172186066099445416, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            #[doc = " Query the filesystem for filesystem-specific information.\n"]
            pub fn query_filesystem(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::QueryFilesystem, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8013111122914313744, ())
                    .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"]
            pub fn get_attributes(
                &self,

                query: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeAttributesQuery,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_attributes_with(GetAttributes { query })
            }

            #[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"]
            pub fn get_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetAttributesRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn update_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::UpdateAttributes, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireMutableNodeAttributes<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn sync(
                &self,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Sync, ___T>, ::fidl_next::EncodeError>
            {
                self.sender
                    .send_two_way(3196473584242777161, ())
                    .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"]
            pub fn list_extended_attributes(
                &self,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::ExtendedAttributeIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.list_extended_attributes_with(ListExtendedAttributes { iterator })
            }

            #[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"]
            pub fn list_extended_attributes_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeListExtendedAttributesRequest,
                >,
            {
                self.sender.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"]
            pub fn get_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.get_extended_attribute_with(GetExtendedAttribute { name })
            }

            #[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"]
            pub fn get_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeGetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn set_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,

                value: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireExtendedAttributeValue<'static>,
                >,

                mode: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireSetExtendedAttributeMode,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.set_extended_attribute_with(SetExtendedAttribute { name, value, mode })
            }

            #[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"]
            pub fn set_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::SetExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeSetExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn remove_extended_attribute(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, u8>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.remove_extended_attribute_with(RemoveExtendedAttribute { name })
            }

            #[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"]
            pub fn remove_extended_attribute_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::RemoveExtendedAttribute, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireNodeRemoveExtendedAttributeRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(8794297771444732717, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }

            pub fn describe(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Describe, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(8371117097481679347, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `Symlink` protocol.
        #[repr(transparent)]
        pub struct SymlinkServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> SymlinkServerSender<___T>
        where
            ___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"]
            pub fn on_open(
                &self,

                s: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireI32,
                >,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireOptionalNodeInfoDeprecated<'static>,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.on_open_with(OnOpen { s, info })
            }

            #[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"]

            pub fn on_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnOpen as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.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"]

            pub fn on_representation_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnRepresentation as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(6679970090861613324, request)
            }
        }
    }
}

/// 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<Symlink, ___T>,

        event: ::fidl_next::Response<symlink::OnOpen, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        event: ::fidl_next::Response<symlink::OnRepresentation, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<Symlink, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Symlink
where
    ___H: SymlinkClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <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::DeprecatedGetAttr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedSetAttr 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::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>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            9207534335756671346 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_open(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6679970090861613324 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_representation(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// 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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::LinkInto, ___T>,

        responder: ::fidl_next::Responder<symlink::LinkInto>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn clone(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::Clone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::Close>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn query(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::Query>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `fuchsia.unknown/Cloneable.Clone` instead.\n"]
    fn deprecated_clone(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::DeprecatedClone, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n"]
    fn deprecated_get_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
    fn deprecated_set_attr(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,

        responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
    fn deprecated_get_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
    fn deprecated_set_flags(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,

        responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::GetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::SetFlags, ___T>,

        responder: ::fidl_next::Responder<symlink::SetFlags>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Query the filesystem for filesystem-specific information.\n"]
    fn query_filesystem(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::QueryFilesystem>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::GetAttributes, ___T>,

        responder: ::fidl_next::Responder<symlink::GetAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,

        responder: ::fidl_next::Responder<symlink::UpdateAttributes>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::Sync>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<symlink::GetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<symlink::SetExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[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<Symlink, ___T>,

        request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,

        responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn describe(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,

        responder: ::fidl_next::Responder<symlink::Describe>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<Symlink, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Symlink
where
    ___H: SymlinkServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <symlink::LinkInto as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::Clone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedClone as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedSetAttr as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::DeprecatedSetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::SetFlags as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::UpdateAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::ListExtendedAttributes as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::GetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::SetExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <symlink::RemoveExtendedAttribute as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            6512600400724287855 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.deprecated_clone(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            5431626189872037072 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.list_extended_attributes(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.link_into(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6540867515453498750 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.close(sender, responder).await;
            }

            2763219980499352582 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query(sender, responder).await;
            }

            8689798978500614909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_attr(sender, responder).await;
            }

            4721673413776871238 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_attr(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            6595803110182632097 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.deprecated_get_flags(sender, responder).await;
            }

            5950864159036794675 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.deprecated_set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            105530239381466147 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_flags(sender, responder).await;
            }

            6172186066099445416 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_flags(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8013111122914313744 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.query_filesystem(sender, responder).await;
            }

            4414537700416816443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3677402239314018056 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.update_attributes(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            3196473584242777161 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.sync(sender, responder).await;
            }

            5043930208506967771 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            5374223046099989052 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.set_extended_attribute(sender, decoded, responder).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8794297771444732717 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.remove_extended_attribute(sender, decoded, responder).await
                    }
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8371117097481679347 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.describe(sender, responder).await;
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[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;
}
impl ::std::convert::TryFrom<u8> for WatchEvent {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::Deleted),
            1 => Ok(Self::Added),
            2 => Ok(Self::Removed),
            3 => Ok(Self::Existing),
            4 => Ok(Self::Idle),

            _ => Err(Self::Error::new(value.into())),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for WatchEvent
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WatchEvent
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &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::FromWire<WireWatchEvent> for WatchEvent {
    #[inline]
    fn from_wire(wire: WireWatchEvent) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireWatchEvent> for WatchEvent {
    #[inline]
    fn from_wire_ref(wire: &WireWatchEvent) -> Self {
        Self::from(*wire)
    }
}

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

unsafe impl ::fidl_next::Wire for WireWatchEvent {
    type Decoded<'de> = Self;

    #[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 ::core::convert::From<crate::Operations> for ::fidl_fuchsia_io::Operations {
        #[inline]
        fn from(from: crate::Operations) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::SeekOrigin> for ::fidl_fuchsia_io::SeekOrigin {
        #[inline]
        fn from(from: crate::SeekOrigin) -> Self {
            match crate::SeekOrigin::from(from) {
                crate::SeekOrigin::Start => Self::Start,

                crate::SeekOrigin::Current => Self::Current,

                crate::SeekOrigin::End => Self::End,
            }
        }
    }

    impl ::core::convert::From<crate::AdvisoryLockType> for ::fidl_fuchsia_io::AdvisoryLockType {
        #[inline]
        fn from(from: crate::AdvisoryLockType) -> Self {
            match crate::AdvisoryLockType::from(from) {
                crate::AdvisoryLockType::Read => Self::Read,

                crate::AdvisoryLockType::Write => Self::Write,

                crate::AdvisoryLockType::Unlock => Self::Unlock,
            }
        }
    }

    #[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 ::core::convert::From<crate::AdvisoryLocking> for ::fidl_fuchsia_io::AdvisoryLockingMarker {
        #[inline]
        fn from(_: crate::AdvisoryLocking) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::AllocateMode> for ::fidl_fuchsia_io::AllocateMode {
        #[inline]
        fn from(from: crate::AllocateMode) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::OpenFlags> for ::fidl_fuchsia_io::OpenFlags {
        #[inline]
        fn from(from: crate::OpenFlags) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::NodeAttributeFlags> for ::fidl_fuchsia_io::NodeAttributeFlags {
        #[inline]
        fn from(from: crate::NodeAttributeFlags) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::ModeType> for ::fidl_fuchsia_io::ModeType {
        #[inline]
        fn from(from: crate::ModeType) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::UnlinkFlags> for ::fidl_fuchsia_io::UnlinkFlags {
        #[inline]
        fn from(from: crate::UnlinkFlags) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::WatchMask> for ::fidl_fuchsia_io::WatchMask {
        #[inline]
        fn from(from: crate::WatchMask) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::SetExtendedAttributeMode>
        for ::fidl_fuchsia_io::SetExtendedAttributeMode
    {
        #[inline]
        fn from(from: crate::SetExtendedAttributeMode) -> Self {
            match crate::SetExtendedAttributeMode::from(from) {
                crate::SetExtendedAttributeMode::Set => Self::Set,

                crate::SetExtendedAttributeMode::Create => Self::Create,

                crate::SetExtendedAttributeMode::Replace => Self::Replace,
            }
        }
    }

    impl ::core::convert::From<crate::Flags> for ::fidl_fuchsia_io::Flags {
        #[inline]
        fn from(from: crate::Flags) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::NodeProtocolKinds> for ::fidl_fuchsia_io::NodeProtocolKinds {
        #[inline]
        fn from(from: crate::NodeProtocolKinds) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    impl ::core::convert::From<crate::HashAlgorithm> for ::fidl_fuchsia_io::HashAlgorithm {
        #[inline]
        fn from(from: crate::HashAlgorithm) -> 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 ::core::convert::From<crate::NodeAttributesQuery> for ::fidl_fuchsia_io::NodeAttributesQuery {
        #[inline]
        fn from(from: crate::NodeAttributesQuery) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    #[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 ::core::convert::From<crate::Node> for ::fidl_fuchsia_io::NodeMarker {
        #[inline]
        fn from(_: crate::Node) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::Directory> for ::fidl_fuchsia_io::DirectoryMarker {
        #[inline]
        fn from(_: crate::Directory) -> 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 ::core::convert::From<crate::DirectoryWatcher> for ::fidl_fuchsia_io::DirectoryWatcherMarker {
        #[inline]
        fn from(_: crate::DirectoryWatcher) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::DirentType> for ::fidl_fuchsia_io::DirentType {
        #[inline]
        fn from(from: crate::DirentType) -> 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 }
                }
            }
        }
    }

    #[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 ::core::convert::From<crate::ExtendedAttributeIterator>
        for ::fidl_fuchsia_io::ExtendedAttributeIteratorMarker
    {
        #[inline]
        fn from(_: crate::ExtendedAttributeIterator) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::Readable> for ::fidl_fuchsia_io::ReadableMarker {
        #[inline]
        fn from(_: crate::Readable) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::Writable> for ::fidl_fuchsia_io::WritableMarker {
        #[inline]
        fn from(_: crate::Writable) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::VmoFlags> for ::fidl_fuchsia_io::VmoFlags {
        #[inline]
        fn from(from: crate::VmoFlags) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    #[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 ::core::convert::From<crate::Linkable> for ::fidl_fuchsia_io::LinkableMarker {
        #[inline]
        fn from(_: crate::Linkable) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::File> for ::fidl_fuchsia_io::FileMarker {
        #[inline]
        fn from(_: crate::File) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::FileSignal> for ::fidl_fuchsia_io::FileSignal {
        #[inline]
        fn from(from: crate::FileSignal) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }

    #[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 ::core::convert::From<crate::Symlink> for ::fidl_fuchsia_io::SymlinkMarker {
        #[inline]
        fn from(_: crate::Symlink) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::WatchEvent> for ::fidl_fuchsia_io::WatchEvent {
        #[inline]
        fn from(from: crate::WatchEvent) -> 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,
            }
        }
    }
}