fidl_next_fuchsia_component_sandbox/

fidl_next_fuchsia_component_sandbox.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)]

#[doc = " Describes the expected availability of the capability.\n\n Some capabilities may not be present on all system configurations. In those\n cases, the availability will be declared as `OPTIONAL` along the chains of\n exposes/offers/uses, and the capability would be routed from `void` on\n system configurations where it does not make sense to route or provide a\n particular capability (e.g. graphical capabilities on a headless system).\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum Availability {
    Required = 1,
    Optional = 2,
    SameAsTarget = 3,
    Transitional = 4,
}

impl ::fidl_next::Encodable for Availability {
    type Encoded = WireAvailability;
}
impl ::std::convert::TryFrom<u32> for Availability {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Required),
            2 => Ok(Self::Optional),
            3 => Ok(Self::SameAsTarget),
            4 => Ok(Self::Transitional),

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

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

            Self::Optional => 2,

            Self::SameAsTarget => 3,

            Self::Transitional => 4,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireAvailability> for Availability {
    fn from(wire: WireAvailability) -> Self {
        match u32::from(wire.value) {
            1 => Self::Required,

            2 => Self::Optional,

            3 => Self::SameAsTarget,

            4 => Self::Transitional,

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

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

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

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

impl WireAvailability {
    pub const REQUIRED: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(1) };

    pub const OPTIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(2) };

    pub const SAME_AS_TARGET: WireAvailability =
        WireAvailability { value: ::fidl_next::WireU32(3) };

    pub const TRANSITIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(4) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireAvailability
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 | 4 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

impl ::core::convert::From<Availability> for WireAvailability {
    fn from(natural: Availability) -> Self {
        match natural {
            Availability::Required => WireAvailability::REQUIRED,

            Availability::Optional => WireAvailability::OPTIONAL,

            Availability::SameAsTarget => WireAvailability::SAME_AS_TARGET,

            Availability::Transitional => WireAvailability::TRANSITIONAL,
        }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct Unit {}

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

    type Encoded = WireUnit;
}

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

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Unit> {
    type EncodedOption = ::fidl_next::WireBox<WireUnit>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnit
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(())
    }
}

#[doc = " Maximum number of bytes in a [Data].\n"]
pub const MAX_DATA_LENGTH: u32 = 8192;

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

    String(String),

    Int64(i64),

    Uint64(u64),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Data {
    type Encoded = WireData;
}

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

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

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

            Self::String(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, String>(value, 2, encoder, raw)?
            }

            Self::Int64(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, i64>(value, 3, encoder, raw)?
            }

            Self::Uint64(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, u64>(value, 4, encoder, raw)?
            }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Data> {
    type EncodedOption = WireOptionalData;
}

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

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

        Ok(())
    }
}

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

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

            3 => Self::Int64(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireI64>()
            })),

            4 => Self::Uint64(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireU64>()
            })),

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

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

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

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

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

        String(&'union ::fidl_next::WireString),

        Int64(&'union ::fidl_next::WireI64),

        Uint64(&'union ::fidl_next::WireU64),

        UnknownOrdinal_(u64),
    }
}

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

            2 => crate::data::Ref::String(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString>()
            }),

            3 => crate::data::Ref::Int64(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireI64>()
            }),

            4 => crate::data::Ref::Uint64(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU64>()
            }),

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

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

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

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

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireData {
    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::WireString>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

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

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

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

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

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

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,

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

        Ok(())
    }
}

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

#[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
pub type Token = ::fidl_next::fuchsia::zx::Handle;

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

#[derive(Debug)]
#[repr(C)]
pub struct DictionaryRef {
    pub token: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireDictionaryRef;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryRef> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryRef>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryRef> for DictionaryRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`DictionaryRef`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryRef {
    pub token: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryRef
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 token,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct Connector {
    pub token: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireConnector;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Connector> {
    type EncodedOption = ::fidl_next::WireBox<WireConnector>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConnector> for Connector {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`Connector`].
#[derive(Debug)]
#[repr(C)]
pub struct WireConnector {
    pub token: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnector
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 token,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirConnector {
    pub token: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireDirConnector;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirConnector> {
    type EncodedOption = ::fidl_next::WireBox<WireDirConnector>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirConnector> for DirConnector {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`DirConnector`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirConnector {
    pub token: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirConnector
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 token,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirEntry {
    pub token: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireDirEntry;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirEntry> {
    type EncodedOption = ::fidl_next::WireBox<WireDirEntry>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirEntry> for DirEntry {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`DirEntry`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirEntry {
    pub token: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirEntry
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 token,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub enum Capability {
    Unit(crate::Unit),

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

    Data(crate::Data),

    Dictionary(crate::DictionaryRef),

    Connector(crate::Connector),

    DirConnector(crate::DirConnector),

    Directory(
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    ),

    DirEntry(crate::DirEntry),

    ConnectorRouter(
        ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::ConnectorRouter>,
    ),

    DictionaryRouter(
        ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DictionaryRouter>,
    ),

    DirEntryRouter(
        ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DirEntryRouter>,
    ),

    DataRouter(::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DataRouter>),

    DirConnectorRouter(
        ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DirConnectorRouter>,
    ),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Capability {
    type Encoded = WireCapability;
}

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

    ___E: ::fidl_next::Encoder,

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

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

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

            Self::Data(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Data>(value, 3, encoder, raw)?
            }

            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DictionaryRef,
            >(value, 4, encoder, raw)?,

            Self::Connector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Connector>(
                    value, 5, encoder, raw,
                )?
            }

            Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DirConnector,
            >(value, 6, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::zx::Channel,
                    ::fidl_next_fuchsia_io::Directory,
                >,
            >(value, 7, encoder, raw)?,

            Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::DirEntry>(
                value, 8, encoder, raw,
            )?,

            Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::ConnectorRouter>,
            >(value, 9, encoder, raw)?,

            Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DictionaryRouter>,
            >(value, 10, encoder, raw)?,

            Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DirEntryRouter>,
            >(value, 11, encoder, raw)?,

            Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DataRouter>,
            >(value, 12, encoder, raw)?,

            Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::zx::Channel,
                    crate::DirConnectorRouter,
                >,
            >(value, 13, encoder, raw)?,

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Capability> {
    type EncodedOption = WireOptionalCapability;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapability> for Capability {
    #[inline]
    fn take_from(from: &WireCapability) -> Self {
        match from.raw.ordinal() {
            1 => Self::Unit(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireUnit>()
            })),

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

            3 => Self::Data(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireData>()
            })),

            4 => Self::Dictionary(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
            })),

            5 => Self::Connector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireConnector>()
            })),

            6 => Self::DirConnector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirConnector>()
            })),

            7 => Self::Directory(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >>()
            })),

            8 => Self::DirEntry(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirEntry>()
            })),

            9 => Self::ConnectorRouter(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::ConnectorRouter,
                >>()
            })),

            10 => Self::DictionaryRouter(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DictionaryRouter,
                >>()
            })),

            11 => Self::DirEntryRouter(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DirEntryRouter,
        >>()
            })),

            12 => Self::DataRouter(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DataRouter,
        >>()
            })),

            13 => Self::DirConnectorRouter(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DirConnectorRouter,
                >>()
            })),

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

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

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

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

pub mod capability {
    pub enum Ref<'union> {
        Unit(&'union crate::WireUnit),

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

        Data(&'union crate::WireData),

        Dictionary(&'union crate::WireDictionaryRef),

        Connector(&'union crate::WireConnector),

        DirConnector(&'union crate::WireDirConnector),

        Directory(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Directory,
            >,
        ),

        DirEntry(&'union crate::WireDirEntry),

        ConnectorRouter(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                crate::ConnectorRouter,
            >,
        ),

        DictionaryRouter(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                crate::DictionaryRouter,
            >,
        ),

        DirEntryRouter(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                crate::DirEntryRouter,
            >,
        ),

        DataRouter(
            &'union ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DataRouter>,
        ),

        DirConnectorRouter(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                crate::DirConnectorRouter,
            >,
        ),

        UnknownOrdinal_(u64),
    }
}

impl WireCapability {
    pub fn as_ref(&self) -> crate::capability::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::capability::Ref::Unit(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

            3 => crate::capability::Ref::Data(unsafe {
                self.raw.get().deref_unchecked::<crate::WireData>()
            }),

            4 => crate::capability::Ref::Dictionary(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
            }),

            5 => crate::capability::Ref::Connector(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConnector>()
            }),

            6 => crate::capability::Ref::DirConnector(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirConnector>()
            }),

            7 => crate::capability::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >>()
            }),

            8 => crate::capability::Ref::DirEntry(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirEntry>()
            }),

            9 => crate::capability::Ref::ConnectorRouter(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::ConnectorRouter,
                >>()
            }),

            10 => crate::capability::Ref::DictionaryRouter(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DictionaryRouter,
                >>()
            }),

            11 => crate::capability::Ref::DirEntryRouter(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DirEntryRouter,
        >>()
            }),

            12 => crate::capability::Ref::DataRouter(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DataRouter,
        >>()
            }),

            13 => crate::capability::Ref::DirConnectorRouter(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DirConnectorRouter,
                >>()
            }),

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

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

    ___D: ::fidl_next::Decoder,

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

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

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

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

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,

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

            7 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >,
            >(raw, decoder)?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,

            9 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::ConnectorRouter>,
            >(raw, decoder)?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DictionaryRouter>,
            >(raw, decoder)?,

            11 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DirEntryRouter>,
            >(raw, decoder)?,

            12 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DataRouter>,
            >(raw, decoder)?,

            13 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DirConnectorRouter,
                >,
            >(raw, decoder)?,

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireCapability {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
            2 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
            },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireData>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionaryRef>().fmt(f) },
            5 => unsafe { self.raw.get().deref_unchecked::<crate::WireConnector>().fmt(f) },
            6 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirConnector>().fmt(f) },
            7 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_io::Directory,
                    >>()
                    .fmt(f)
            },
            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
            9 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        crate::ConnectorRouter,
                    >>()
                    .fmt(f)
            },
            10 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        crate::DictionaryRouter,
                    >>()
                    .fmt(f)
            },
            11 => unsafe {
                self.raw.get().deref_unchecked::<
                            ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DirEntryRouter,
        >
                        >().fmt(f)
            },
            12 => unsafe {
                self.raw.get().deref_unchecked::<
                            ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::DataRouter,
        >
                        >().fmt(f)
            },
            13 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        crate::DirConnectorRouter,
                    >>()
                    .fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

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

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

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

    ___D: ::fidl_next::Decoder,

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

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

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

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

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,

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

            7 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >,
            >(raw, decoder)?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,

            9 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::ConnectorRouter>,
            >(raw, decoder)?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DictionaryRouter>,
            >(raw, decoder)?,

            11 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DirEntryRouter>,
            >(raw, decoder)?,

            12 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DataRouter>,
            >(raw, decoder)?,

            13 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    crate::DirConnectorRouter,
                >,
            >(raw, decoder)?,

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

        Ok(())
    }
}

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

#[doc = " A client-assigned id of a [Capability] in a [CapabilityStore].\n\n The id is relative to the [CapabilityStore]. In the case where two\n [CapabilityStore]s have a capability / assigned to the same id, there is\n no relation between them\n"]
pub type CapabilityId = u64;

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

#[doc = " A client-assigned id of a new [Capability] in a [CapabilityStore]. Same as [CapabilityId],\n but used to distinguish output parameters in [CapabilityStore] methods.\n"]
pub type NewCapabilityId = u64;

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

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CapabilityStoreDuplicateRequest {
    pub id: u64,

    pub dest_id: u64,
}

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

    type Encoded = WireCapabilityStoreDuplicateRequest;
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDuplicateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDuplicateRequest>;
}

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

        Ok(())
    }
}

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

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

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

/// The wire type corresponding to [`CapabilityStoreDuplicateRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDuplicateRequest {
    pub id: ::fidl_next::WireU64,

    pub dest_id: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDuplicateRequest
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 id,
                mut dest_id,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDuplicateResponse = ();

/// The wire type corresponding to [`CapabilityStoreDuplicateResponse`].
pub type WireCapabilityStoreDuplicateResponse = ();

#[doc = " Error returned from methods in [CapabilityStore].\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum CapabilityStoreError {
    IdNotFound = 1,
    IdAlreadyExists = 2,
    BadCapability = 3,
    WrongType = 4,
    NotDuplicatable = 5,
    ItemNotFound = 6,
    ItemAlreadyExists = 7,
    InvalidKey = 8,
    InvalidArgs = 9,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for CapabilityStoreError {
    type Encoded = WireCapabilityStoreError;
}
impl ::std::convert::From<u32> for CapabilityStoreError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::IdNotFound,
            2 => Self::IdAlreadyExists,
            3 => Self::BadCapability,
            4 => Self::WrongType,
            5 => Self::NotDuplicatable,
            6 => Self::ItemNotFound,
            7 => Self::ItemAlreadyExists,
            8 => Self::InvalidKey,
            9 => Self::InvalidArgs,

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

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

            Self::IdAlreadyExists => 2,

            Self::BadCapability => 3,

            Self::WrongType => 4,

            Self::NotDuplicatable => 5,

            Self::ItemNotFound => 6,

            Self::ItemAlreadyExists => 7,

            Self::InvalidKey => 8,

            Self::InvalidArgs => 9,

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

        Ok(())
    }
}

impl ::core::convert::From<WireCapabilityStoreError> for CapabilityStoreError {
    fn from(wire: WireCapabilityStoreError) -> Self {
        match u32::from(wire.value) {
            1 => Self::IdNotFound,

            2 => Self::IdAlreadyExists,

            3 => Self::BadCapability,

            4 => Self::WrongType,

            5 => Self::NotDuplicatable,

            6 => Self::ItemNotFound,

            7 => Self::ItemAlreadyExists,

            8 => Self::InvalidKey,

            9 => Self::InvalidArgs,

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

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

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

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

impl WireCapabilityStoreError {
    pub const ID_NOT_FOUND: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(1) };

    pub const ID_ALREADY_EXISTS: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(2) };

    pub const BAD_CAPABILITY: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(3) };

    pub const WRONG_TYPE: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(4) };

    pub const NOT_DUPLICATABLE: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(5) };

    pub const ITEM_NOT_FOUND: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(6) };

    pub const ITEM_ALREADY_EXISTS: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(7) };

    pub const INVALID_KEY: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(8) };

    pub const INVALID_ARGS: WireCapabilityStoreError =
        WireCapabilityStoreError { value: ::fidl_next::WireU32(9) };
}

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

impl ::core::convert::From<CapabilityStoreError> for WireCapabilityStoreError {
    fn from(natural: CapabilityStoreError) -> Self {
        match natural {
            CapabilityStoreError::IdNotFound => WireCapabilityStoreError::ID_NOT_FOUND,

            CapabilityStoreError::IdAlreadyExists => WireCapabilityStoreError::ID_ALREADY_EXISTS,

            CapabilityStoreError::BadCapability => WireCapabilityStoreError::BAD_CAPABILITY,

            CapabilityStoreError::WrongType => WireCapabilityStoreError::WRONG_TYPE,

            CapabilityStoreError::NotDuplicatable => WireCapabilityStoreError::NOT_DUPLICATABLE,

            CapabilityStoreError::ItemNotFound => WireCapabilityStoreError::ITEM_NOT_FOUND,

            CapabilityStoreError::ItemAlreadyExists => {
                WireCapabilityStoreError::ITEM_ALREADY_EXISTS
            }

            CapabilityStoreError::InvalidKey => WireCapabilityStoreError::INVALID_KEY,

            CapabilityStoreError::InvalidArgs => WireCapabilityStoreError::INVALID_ARGS,

            CapabilityStoreError::UnknownOrdinal_(value) => {
                WireCapabilityStoreError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

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

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

    type Encoded = WireCapabilityStoreDropRequest;
}

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDropRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDropRequest>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDropRequest
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 id,

            } = slot;
        }

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

        Ok(())
    }
}

pub type CapabilityStoreDropResponse = ();

/// The wire type corresponding to [`CapabilityStoreDropResponse`].
pub type WireCapabilityStoreDropResponse = ();

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

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

    type Encoded = WireCapabilityStoreExportRequest;
}

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreExportRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreExportRequest>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportRequest
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 id,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct CapabilityStoreExportResponse {
    pub capability: crate::Capability,
}

impl ::fidl_next::Encodable for CapabilityStoreExportResponse {
    type Encoded = WireCapabilityStoreExportResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreExportResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreExportResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreExportResponse> for CapabilityStoreExportResponse {
    #[inline]
    fn take_from(from: &WireCapabilityStoreExportResponse) -> Self {
        Self { capability: ::fidl_next::TakeFrom::take_from(&from.capability) }
    }
}

/// The wire type corresponding to [`CapabilityStoreExportResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreExportResponse {
    pub capability: crate::WireCapability,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportResponse
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 capability,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct CapabilityStoreImportRequest {
    pub id: u64,

    pub capability: crate::Capability,
}

impl ::fidl_next::Encodable for CapabilityStoreImportRequest {
    type Encoded = WireCapabilityStoreImportRequest;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreImportRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreImportRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreImportRequest> for CapabilityStoreImportRequest {
    #[inline]
    fn take_from(from: &WireCapabilityStoreImportRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreImportRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreImportRequest {
    pub id: ::fidl_next::WireU64,

    pub capability: crate::WireCapability,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreImportRequest
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 id,
                mut capability,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreImportResponse = ();

/// The wire type corresponding to [`CapabilityStoreImportResponse`].
pub type WireCapabilityStoreImportResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreConnectorCreateRequest {
    pub id: u64,

    pub receiver: ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::Receiver>,
}

impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest {
    type Encoded = WireCapabilityStoreConnectorCreateRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreConnectorCreateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreConnectorCreateRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreConnectorCreateRequest>
    for CapabilityStoreConnectorCreateRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreConnectorCreateRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreConnectorCreateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreConnectorCreateRequest {
    pub id: ::fidl_next::WireU64,

    pub receiver: ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::Receiver>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorCreateRequest
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 id,
                mut receiver,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreConnectorCreateResponse = ();

/// The wire type corresponding to [`CapabilityStoreConnectorCreateResponse`].
pub type WireCapabilityStoreConnectorCreateResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreConnectorOpenRequest {
    pub id: u64,

    pub server_end: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest {
    type Encoded = WireCapabilityStoreConnectorOpenRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreConnectorOpenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreConnectorOpenRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreConnectorOpenRequest>
    for CapabilityStoreConnectorOpenRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreConnectorOpenRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreConnectorOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreConnectorOpenRequest {
    pub id: ::fidl_next::WireU64,

    pub server_end: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorOpenRequest
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 id,
                mut server_end,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreConnectorOpenResponse = ();

/// The wire type corresponding to [`CapabilityStoreConnectorOpenResponse`].
pub type WireCapabilityStoreConnectorOpenResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDirConnectorCreateRequest {
    pub id: u64,

    pub receiver: ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::DirReceiver>,
}

impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest {
    type Encoded = WireCapabilityStoreDirConnectorCreateRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDirConnectorCreateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDirConnectorCreateRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDirConnectorCreateRequest>
    for CapabilityStoreDirConnectorCreateRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDirConnectorCreateRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDirConnectorCreateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDirConnectorCreateRequest {
    pub id: ::fidl_next::WireU64,

    pub receiver: ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::DirReceiver>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorCreateRequest
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 id,
                mut receiver,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDirConnectorCreateResponse = ();

/// The wire type corresponding to [`CapabilityStoreDirConnectorCreateResponse`].
pub type WireCapabilityStoreDirConnectorCreateResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDirConnectorOpenRequest {
    pub id: u64,

    pub server_end: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::zx::Channel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest {
    type Encoded = WireCapabilityStoreDirConnectorOpenRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDirConnectorOpenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDirConnectorOpenRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDirConnectorOpenRequest>
    for CapabilityStoreDirConnectorOpenRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDirConnectorOpenRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDirConnectorOpenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDirConnectorOpenRequest {
    pub id: ::fidl_next::WireU64,

    pub server_end: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorOpenRequest
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 id,
                mut server_end,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDirConnectorOpenResponse = ();

/// The wire type corresponding to [`CapabilityStoreDirConnectorOpenResponse`].
pub type WireCapabilityStoreDirConnectorOpenResponse = ();

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

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

    type Encoded = WireCapabilityStoreDictionaryCreateRequest;
}

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryCreateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryCreateRequest>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCreateRequest
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 id,

            } = slot;
        }

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryCreateResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryCreateResponse`].
pub type WireCapabilityStoreDictionaryCreateResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDictionaryLegacyImportRequest {
    pub id: u64,

    pub client_end: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest {
    type Encoded = WireCapabilityStoreDictionaryLegacyImportRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryLegacyImportRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryLegacyImportRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryLegacyImportRequest>
    for CapabilityStoreDictionaryLegacyImportRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryLegacyImportRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryLegacyImportRequest {
    pub id: ::fidl_next::WireU64,

    pub client_end: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyImportRequest
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 id,
                mut client_end,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryLegacyImportResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportResponse`].
pub type WireCapabilityStoreDictionaryLegacyImportResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDictionaryLegacyExportRequest {
    pub id: u64,

    pub server_end: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest {
    type Encoded = WireCapabilityStoreDictionaryLegacyExportRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryLegacyExportRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryLegacyExportRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryLegacyExportRequest>
    for CapabilityStoreDictionaryLegacyExportRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryLegacyExportRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryLegacyExportRequest {
    pub id: ::fidl_next::WireU64,

    pub server_end: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyExportRequest
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 id,
                mut server_end,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryLegacyExportResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportResponse`].
pub type WireCapabilityStoreDictionaryLegacyExportResponse = ();

#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
pub const MAX_NAME_LENGTH: u64 = 255;

#[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
pub type DictionaryKey = String;

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

#[doc = " A key-value pair in a [`DictionaryRef`].\n"]
#[derive(Clone, Debug)]
pub struct DictionaryItem {
    pub key: String,

    pub value: u64,
}

impl ::fidl_next::Encodable for DictionaryItem {
    type Encoded = WireDictionaryItem;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryItem> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryItem>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryItem> for DictionaryItem {
    #[inline]
    fn take_from(from: &WireDictionaryItem) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

    pub value: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryItem
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 key,
                mut value,

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct CapabilityStoreDictionaryInsertRequest {
    pub id: u64,

    pub item: crate::DictionaryItem,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest {
    type Encoded = WireCapabilityStoreDictionaryInsertRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryInsertRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryInsertRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryInsertRequest>
    for CapabilityStoreDictionaryInsertRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryInsertRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryInsertRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryInsertRequest {
    pub id: ::fidl_next::WireU64,

    pub item: crate::WireDictionaryItem,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryInsertRequest
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 id,
                mut item,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryInsertResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryInsertResponse`].
pub type WireCapabilityStoreDictionaryInsertResponse = ();

#[derive(Clone, Debug)]
pub struct CapabilityStoreDictionaryGetRequest {
    pub id: u64,

    pub key: String,

    pub dest_id: u64,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest {
    type Encoded = WireCapabilityStoreDictionaryGetRequest;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryGetRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryGetRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryGetRequest>
    for CapabilityStoreDictionaryGetRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryGetRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

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

/// The wire type corresponding to [`CapabilityStoreDictionaryGetRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryGetRequest {
    pub id: ::fidl_next::WireU64,

    pub key: ::fidl_next::WireString,

    pub dest_id: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryGetRequest
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 id,
                mut key,
                mut dest_id,

            } = slot;
        }

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

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

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

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryGetResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryGetResponse`].
pub type WireCapabilityStoreDictionaryGetResponse = ();

#[doc = " A [CapabilityId] wrapped in a struct. This is useful for putting a [CapabilityId] in a `box<>`,\n which FIDL does not allow for pure integral types.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WrappedCapabilityId {
    pub id: u64,
}

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

    type Encoded = WireWrappedCapabilityId;
}

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<WrappedCapabilityId> {
    type EncodedOption = ::fidl_next::WireBox<WireWrappedCapabilityId>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireWrappedCapabilityId
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 id,

            } = slot;
        }

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

        Ok(())
    }
}

pub type WrappedNewCapabilityId = crate::WrappedCapabilityId;

/// The wire type corresponding to [`WrappedNewCapabilityId`].
pub type WireWrappedNewCapabilityId = crate::WireWrappedCapabilityId;

#[derive(Clone, Debug)]
pub struct CapabilityStoreDictionaryRemoveRequest {
    pub id: u64,

    pub key: String,

    pub dest_id: Option<Box<crate::WrappedCapabilityId>>,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest {
    type Encoded = WireCapabilityStoreDictionaryRemoveRequest;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryRemoveRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryRemoveRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryRemoveRequest>
    for CapabilityStoreDictionaryRemoveRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryRemoveRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

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

/// The wire type corresponding to [`CapabilityStoreDictionaryRemoveRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryRemoveRequest {
    pub id: ::fidl_next::WireU64,

    pub key: ::fidl_next::WireString,

    pub dest_id: ::fidl_next::WireBox<crate::WireWrappedCapabilityId>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryRemoveRequest
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 id,
                mut key,
                mut dest_id,

            } = slot;
        }

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

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

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

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryRemoveResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryRemoveResponse`].
pub type WireCapabilityStoreDictionaryRemoveResponse = ();

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CapabilityStoreDictionaryCopyRequest {
    pub id: u64,

    pub dest_id: u64,
}

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

    type Encoded = WireCapabilityStoreDictionaryCopyRequest;
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryCopyRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryCopyRequest>;
}

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

        Ok(())
    }
}

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

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

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

/// The wire type corresponding to [`CapabilityStoreDictionaryCopyRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryCopyRequest {
    pub id: ::fidl_next::WireU64,

    pub dest_id: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCopyRequest
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 id,
                mut dest_id,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryCopyResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryCopyResponse`].
pub type WireCapabilityStoreDictionaryCopyResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDictionaryKeysRequest {
    pub id: u64,

    pub iterator:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::DictionaryKeysIterator>,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest {
    type Encoded = WireCapabilityStoreDictionaryKeysRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryKeysRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryKeysRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryKeysRequest>
    for CapabilityStoreDictionaryKeysRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryKeysRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryKeysRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryKeysRequest {
    pub id: ::fidl_next::WireU64,

    pub iterator:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::DictionaryKeysIterator>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryKeysRequest
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 id,
                mut iterator,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryKeysResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryKeysResponse`].
pub type WireCapabilityStoreDictionaryKeysResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDictionaryEnumerateRequest {
    pub id: u64,

    pub iterator: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::zx::Channel,
        crate::DictionaryEnumerateIterator,
    >,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest {
    type Encoded = WireCapabilityStoreDictionaryEnumerateRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryEnumerateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryEnumerateRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryEnumerateRequest>
    for CapabilityStoreDictionaryEnumerateRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryEnumerateRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryEnumerateRequest {
    pub id: ::fidl_next::WireU64,

    pub iterator: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireChannel,
        crate::DictionaryEnumerateIterator,
    >,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryEnumerateRequest
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 id,
                mut iterator,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryEnumerateResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateResponse`].
pub type WireCapabilityStoreDictionaryEnumerateResponse = ();

#[derive(Debug)]
pub struct CapabilityStoreDictionaryDrainRequest {
    pub id: u64,

    pub iterator: ::fidl_next::ServerEnd<
        Option<::fidl_next::fuchsia::zx::Channel>,
        crate::DictionaryDrainIterator,
    >,
}

impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest {
    type Encoded = WireCapabilityStoreDictionaryDrainRequest;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<CapabilityStoreDictionaryDrainRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireCapabilityStoreDictionaryDrainRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireCapabilityStoreDictionaryDrainRequest>
    for CapabilityStoreDictionaryDrainRequest
{
    #[inline]
    fn take_from(from: &WireCapabilityStoreDictionaryDrainRequest) -> Self {
        Self {
            id: ::fidl_next::TakeFrom::take_from(&from.id),

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

/// The wire type corresponding to [`CapabilityStoreDictionaryDrainRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireCapabilityStoreDictionaryDrainRequest {
    pub id: ::fidl_next::WireU64,

    pub iterator: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireOptionalChannel,
        crate::DictionaryDrainIterator,
    >,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryDrainRequest
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 id,
                mut iterator,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type CapabilityStoreDictionaryDrainResponse = ();

/// The wire type corresponding to [`CapabilityStoreDictionaryDrainResponse`].
pub type WireCapabilityStoreDictionaryDrainResponse = ();

/// The type corresponding to the CapabilityStore protocol.
#[doc = " Protocol that represents the concept of a \"capability store\", a repository\n for [Capability]s that are held by the component framework runtime.\n\n [CapabilityStore] serves as the main bridge between the component runtime and clients\n that enables them to operate on and exchange [Capability]s. A [CapabilityStore] instance\n contains a set of [Capability]s, each of which has a [CapabilityId] assigned by the client.\n\n Normally, a program would not exchange a [CapabilityStore] or [CapabilityId] with other\n programs -- a [CapabilityStore] connection and its enclosed capabilities are intended to\n be \"local\" to a program. Instead, if a program wishes to exchange a [Capability] with other\n programs, it should [Export] the [Capability] out of the store, send the [Capability] to the\n target program, which can then [Import] the capability into its own store.\n\n [CapabilityStore] is also used to manage capability lifetimes. The lifetime of a capability is\n scoped to the [CapabilityStore] in which it resides; i.e. to drop the [CapabilityStore]\n connections to release the capabilities instead it. In addition, [CapabilityStore] supports a\n [Drop] API to drop an individual [Capability] reference. (Note that it is possible for a\n some capabilities, like [DictionaryRef], to have multiple references, in which case all of\n the references must be dropped for the underlying resource to be released.)\n\n A note about semantics: the [CapabilityStore] APIs do not return [CapabilityId]s, because\n [CapabilityId]s are assigned by the client. Instead, when a method would semantically return\n a capability, this is expressed by taking the destination [CapabilityId] as an output parameter.\n"]
#[derive(Debug)]
pub struct CapabilityStore;

impl ::fidl_next::Discoverable for CapabilityStore {
    const PROTOCOL_NAME: &'static str = "capability_store";
}

pub mod capability_store {
    pub mod prelude {
        pub use crate::{
            capability_store, CapabilityStore, CapabilityStoreClientHandler,
            CapabilityStoreClientSender, CapabilityStoreServerHandler, CapabilityStoreServerSender,
        };

        pub use crate::CapabilityStoreConnectorCreateRequest;

        pub use crate::CapabilityStoreConnectorOpenRequest;

        pub use crate::CapabilityStoreDictionaryCopyRequest;

        pub use crate::CapabilityStoreDictionaryCreateRequest;

        pub use crate::CapabilityStoreDictionaryDrainRequest;

        pub use crate::CapabilityStoreDictionaryEnumerateRequest;

        pub use crate::CapabilityStoreDictionaryGetRequest;

        pub use crate::CapabilityStoreDictionaryInsertRequest;

        pub use crate::CapabilityStoreDictionaryKeysRequest;

        pub use crate::CapabilityStoreDictionaryLegacyExportRequest;

        pub use crate::CapabilityStoreDictionaryLegacyImportRequest;

        pub use crate::CapabilityStoreDictionaryRemoveRequest;

        pub use crate::CapabilityStoreDirConnectorCreateRequest;

        pub use crate::CapabilityStoreDirConnectorOpenRequest;

        pub use crate::CapabilityStoreDropRequest;

        pub use crate::CapabilityStoreDuplicateRequest;

        pub use crate::CapabilityStoreError;

        pub use crate::CapabilityStoreExportRequest;

        pub use crate::CapabilityStoreImportRequest;

        pub use crate::CapabilityStoreConnectorCreateResponse;

        pub use crate::CapabilityStoreConnectorOpenResponse;

        pub use crate::CapabilityStoreDictionaryCopyResponse;

        pub use crate::CapabilityStoreDictionaryCreateResponse;

        pub use crate::CapabilityStoreDictionaryDrainResponse;

        pub use crate::CapabilityStoreDictionaryEnumerateResponse;

        pub use crate::CapabilityStoreDictionaryGetResponse;

        pub use crate::CapabilityStoreDictionaryInsertResponse;

        pub use crate::CapabilityStoreDictionaryKeysResponse;

        pub use crate::CapabilityStoreDictionaryLegacyExportResponse;

        pub use crate::CapabilityStoreDictionaryLegacyImportResponse;

        pub use crate::CapabilityStoreDictionaryRemoveResponse;

        pub use crate::CapabilityStoreDirConnectorCreateResponse;

        pub use crate::CapabilityStoreDirConnectorOpenResponse;

        pub use crate::CapabilityStoreDropResponse;

        pub use crate::CapabilityStoreDuplicateResponse;

        pub use crate::CapabilityStoreExportResponse;

        pub use crate::CapabilityStoreImportResponse;
    }

    pub struct Duplicate;

    impl ::fidl_next::Method for Duplicate {
        const ORDINAL: u64 = 6727592627741008260;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDuplicateRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDuplicateResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct Drop;

    impl ::fidl_next::Method for Drop {
        const ORDINAL: u64 = 753328233834620249;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDropRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDropResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct Export;

    impl ::fidl_next::Method for Export {
        const ORDINAL: u64 = 226159162093533951;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreExportRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreExportResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct Import;

    impl ::fidl_next::Method for Import {
        const ORDINAL: u64 = 2276030276116435867;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreImportRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreImportResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct ConnectorCreate;

    impl ::fidl_next::Method for ConnectorCreate {
        const ORDINAL: u64 = 2979461408102095909;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreConnectorCreateRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreConnectorCreateResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct ConnectorOpen;

    impl ::fidl_next::Method for ConnectorOpen {
        const ORDINAL: u64 = 6016362336453278623;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreConnectorOpenRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreConnectorOpenResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DirConnectorCreate;

    impl ::fidl_next::Method for DirConnectorCreate {
        const ORDINAL: u64 = 1756747594275428795;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDirConnectorCreateRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDirConnectorCreateResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DirConnectorOpen;

    impl ::fidl_next::Method for DirConnectorOpen {
        const ORDINAL: u64 = 6219704004220369153;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDirConnectorOpenRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDirConnectorOpenResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryCreate;

    impl ::fidl_next::Method for DictionaryCreate {
        const ORDINAL: u64 = 7608770958894948499;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryCreateRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryCreateResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryLegacyImport;

    impl ::fidl_next::Method for DictionaryLegacyImport {
        const ORDINAL: u64 = 8285893703432012383;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryLegacyImportRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryLegacyImportResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryLegacyExport;

    impl ::fidl_next::Method for DictionaryLegacyExport {
        const ORDINAL: u64 = 4647175832683306445;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryLegacyExportRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryLegacyExportResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryInsert;

    impl ::fidl_next::Method for DictionaryInsert {
        const ORDINAL: u64 = 8575443262986538023;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryInsertRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryInsertResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryGet;

    impl ::fidl_next::Method for DictionaryGet {
        const ORDINAL: u64 = 5592951026866236882;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryGetRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryGetResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryRemove;

    impl ::fidl_next::Method for DictionaryRemove {
        const ORDINAL: u64 = 343892214579320051;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryRemoveRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryRemoveResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryCopy;

    impl ::fidl_next::Method for DictionaryCopy {
        const ORDINAL: u64 = 3977783339739362383;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryCopyRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryCopyResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryKeys;

    impl ::fidl_next::Method for DictionaryKeys {
        const ORDINAL: u64 = 597577248872787102;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryKeysRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryKeysResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryEnumerate;

    impl ::fidl_next::Method for DictionaryEnumerate {
        const ORDINAL: u64 = 964467096271472193;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryEnumerateRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryEnumerateResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct DictionaryDrain;

    impl ::fidl_next::Method for DictionaryDrain {
        const ORDINAL: u64 = 2928364469569621208;

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreDictionaryDrainRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireCapabilityStoreDictionaryDrainResponse,
            crate::WireCapabilityStoreError,
        >;
    }
}

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

    #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
    fn duplicate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Duplicate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDuplicateRequest,
        >;

    #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn drop<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Drop>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDropRequest,
        >;

    #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn export<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Export>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreExportRequest,
        >;

    #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
    fn import<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Import>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreImportRequest,
        >;

    #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn connector_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::ConnectorCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreConnectorCreateRequest,
        >;

    #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn connector_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::ConnectorOpen>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreConnectorOpenRequest,
        >;

    #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dir_connector_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DirConnectorCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest,
        >;

    #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn dir_connector_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DirConnectorOpen>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest,
        >;

    #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dictionary_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryCreateRequest,
        >;

    #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
    fn dictionary_legacy_import<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryLegacyImport>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest,
        >;

    #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn dictionary_legacy_export<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryLegacyExport>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest,
        >;

    #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
    fn dictionary_insert<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryInsert>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryInsertRequest,
        >;

    #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
    fn dictionary_get<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryGet>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryGetRequest,
        >;

    #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
    fn dictionary_remove<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryRemove>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest,
        >;

    #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
    fn dictionary_copy<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryCopy>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryCopyRequest,
        >;

    #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_keys<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryKeys>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryKeysRequest,
        >;

    #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_enumerate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryEnumerate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest,
        >;

    #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_drain<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryDrain>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryDrainRequest,
        >;
}

impl<___T> CapabilityStoreClientSender for ::fidl_next::ClientSender<___T, CapabilityStore>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
    fn duplicate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Duplicate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDuplicateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6727592627741008260, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn drop<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Drop>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDropRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(753328233834620249, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn export<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Export>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreExportRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(226159162093533951, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
    fn import<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::Import>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreImportRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(2276030276116435867, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn connector_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::ConnectorCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreConnectorCreateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(2979461408102095909, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn connector_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::ConnectorOpen>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreConnectorOpenRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6016362336453278623, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dir_connector_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DirConnectorCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(1756747594275428795, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn dir_connector_open<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DirConnectorOpen>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(6219704004220369153, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dictionary_create<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryCreate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryCreateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7608770958894948499, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
    fn dictionary_legacy_import<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryLegacyImport>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8285893703432012383, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn dictionary_legacy_export<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryLegacyExport>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4647175832683306445, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
    fn dictionary_insert<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryInsert>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryInsertRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8575443262986538023, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
    fn dictionary_get<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryGet>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryGetRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5592951026866236882, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
    fn dictionary_remove<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryRemove>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(343892214579320051, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
    fn dictionary_copy<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryCopy>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryCopyRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(3977783339739362383, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_keys<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryKeys>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryKeysRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(597577248872787102, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_enumerate<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryEnumerate>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(964467096271472193, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_drain<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, capability_store::DictionaryDrain>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCapabilityStoreDictionaryDrainRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(2928364469569621208, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the CapabilityStore protocol.
///
/// See [`CapabilityStore`] for more details.
pub trait CapabilityStoreClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, CapabilityStore>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for CapabilityStore
where
    ___T: ::fidl_next::Transport,
    ___H: CapabilityStoreClientHandler<___T>,

    <capability_store::Duplicate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::Drop as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::Export as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::Import as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::ConnectorCreate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::ConnectorOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DirConnectorCreate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DirConnectorOpen as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryCreate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryInsert as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryGet as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryRemove as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryCopy as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryKeys as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

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

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

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

/// A server handler for the CapabilityStore protocol.
///
/// See [`CapabilityStore`] for more details.
pub trait CapabilityStoreServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
    fn duplicate(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::Duplicate>,

        responder: ::fidl_next::Responder<capability_store::Duplicate>,
    );

    #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn drop(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::Drop>,

        responder: ::fidl_next::Responder<capability_store::Drop>,
    );

    #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn export(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::Export>,

        responder: ::fidl_next::Responder<capability_store::Export>,
    );

    #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
    fn import(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::Import>,

        responder: ::fidl_next::Responder<capability_store::Import>,
    );

    #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn connector_create(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::ConnectorCreate>,

        responder: ::fidl_next::Responder<capability_store::ConnectorCreate>,
    );

    #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn connector_open(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::ConnectorOpen>,

        responder: ::fidl_next::Responder<capability_store::ConnectorOpen>,
    );

    #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dir_connector_create(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DirConnectorCreate>,

        responder: ::fidl_next::Responder<capability_store::DirConnectorCreate>,
    );

    #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
    fn dir_connector_open(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DirConnectorOpen>,

        responder: ::fidl_next::Responder<capability_store::DirConnectorOpen>,
    );

    #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
    fn dictionary_create(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryCreate>,

        responder: ::fidl_next::Responder<capability_store::DictionaryCreate>,
    );

    #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
    fn dictionary_legacy_import(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryLegacyImport>,

        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport>,
    );

    #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
    fn dictionary_legacy_export(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryLegacyExport>,

        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport>,
    );

    #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
    fn dictionary_insert(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryInsert>,

        responder: ::fidl_next::Responder<capability_store::DictionaryInsert>,
    );

    #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
    fn dictionary_get(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryGet>,

        responder: ::fidl_next::Responder<capability_store::DictionaryGet>,
    );

    #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
    fn dictionary_remove(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryRemove>,

        responder: ::fidl_next::Responder<capability_store::DictionaryRemove>,
    );

    #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
    fn dictionary_copy(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryCopy>,

        responder: ::fidl_next::Responder<capability_store::DictionaryCopy>,
    );

    #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_keys(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryKeys>,

        responder: ::fidl_next::Responder<capability_store::DictionaryKeys>,
    );

    #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_enumerate(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryEnumerate>,

        responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate>,
    );

    #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
    fn dictionary_drain(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,

        request: ::fidl_next::Request<___T, capability_store::DictionaryDrain>,

        responder: ::fidl_next::Responder<capability_store::DictionaryDrain>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CapabilityStore>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for CapabilityStore
where
    ___T: ::fidl_next::Transport,
    ___H: CapabilityStoreServerHandler<___T>,

    crate::WireCapabilityStoreDuplicateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDropRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreExportRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreImportRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreConnectorCreateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreConnectorOpenRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDirConnectorCreateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDirConnectorOpenRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryCreateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryLegacyImportRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryLegacyExportRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryInsertRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryGetRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryRemoveRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryCopyRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryKeysRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireCapabilityStoreDictionaryEnumerateRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

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

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

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

            753328233834620249 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            226159162093533951 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            2276030276116435867 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            2979461408102095909 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            6016362336453278623 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            1756747594275428795 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            6219704004220369153 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            7608770958894948499 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            8285893703432012383 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            4647175832683306445 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            8575443262986538023 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            5592951026866236882 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            343892214579320051 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            3977783339739362383 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            597577248872787102 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            964467096271472193 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            2928364469569621208 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
#[derive(Debug)]
#[repr(C)]
pub struct InstanceToken {
    pub token: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireInstanceToken;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<InstanceToken> {
    type EncodedOption = ::fidl_next::WireBox<WireInstanceToken>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireInstanceToken> for InstanceToken {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`InstanceToken`].
#[derive(Debug)]
#[repr(C)]
pub struct WireInstanceToken {
    pub token: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireInstanceToken
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 token,

            } = slot;
        }

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

        Ok(())
    }
}

#[doc = " A request for a route.\n"]
#[derive(Debug, Default)]
pub struct RouteRequest {
    pub requesting: Option<crate::InstanceToken>,

    pub metadata: Option<crate::DictionaryRef>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for RouteRequest {
    type Encoded = WireRouteRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for RouteRequest
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 WireRouteRequest { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRouteRequest> for RouteRequest {
    #[inline]
    fn take_from(from: &WireRouteRequest) -> Self {
        Self {
            requesting: from.requesting().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireRouteRequest {
    #[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 WireRouteRequest
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::WireInstanceToken>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

                    Ok(())
                }

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

impl WireRouteRequest {
    pub fn requesting(&self) -> Option<&crate::WireInstanceToken> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[derive(Debug)]
pub enum ConnectorRouterRouteResponse {
    Connector(crate::Connector),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for ConnectorRouterRouteResponse {
    type Encoded = WireConnectorRouterRouteResponse;
}

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

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

        match self {
            Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Connector,
            >(value, 1, encoder, raw)?,

            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Unit,
            >(value, 2, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ConnectorRouterRouteResponse> {
    type EncodedOption = WireOptionalConnectorRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConnectorRouterRouteResponse> for ConnectorRouterRouteResponse {
    #[inline]
    fn take_from(from: &WireConnectorRouterRouteResponse) -> Self {
        match from.raw.ordinal() {
            1 => Self::Connector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireConnector>()
            })),

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

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

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

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

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

pub mod connector_router_route_response {
    pub enum Ref<'union> {
        Connector(&'union crate::WireConnector),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireConnectorRouterRouteResponse {
    pub fn as_ref(&self) -> crate::connector_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::connector_router_route_response::Ref::Connector(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConnector>()
            }),

            2 => crate::connector_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConnectorRouterRouteResponse {
    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 RouterError {
    NotFound = 1,
    InvalidArgs = 2,
    NotSupported = 3,
    Internal = 4,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for RouterError {
    type Encoded = WireRouterError;
}
impl ::std::convert::From<u32> for RouterError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::NotFound,
            2 => Self::InvalidArgs,
            3 => Self::NotSupported,
            4 => Self::Internal,

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

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

            Self::InvalidArgs => 2,

            Self::NotSupported => 3,

            Self::Internal => 4,

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

        Ok(())
    }
}

impl ::core::convert::From<WireRouterError> for RouterError {
    fn from(wire: WireRouterError) -> Self {
        match u32::from(wire.value) {
            1 => Self::NotFound,

            2 => Self::InvalidArgs,

            3 => Self::NotSupported,

            4 => Self::Internal,

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

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

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

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

impl WireRouterError {
    pub const NOT_FOUND: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(1) };

    pub const INVALID_ARGS: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(2) };

    pub const NOT_SUPPORTED: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(3) };

    pub const INTERNAL: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(4) };
}

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

impl ::core::convert::From<RouterError> for WireRouterError {
    fn from(natural: RouterError) -> Self {
        match natural {
            RouterError::NotFound => WireRouterError::NOT_FOUND,

            RouterError::InvalidArgs => WireRouterError::INVALID_ARGS,

            RouterError::NotSupported => WireRouterError::NOT_SUPPORTED,

            RouterError::Internal => WireRouterError::INTERNAL,

            RouterError::UnknownOrdinal_(value) => {
                WireRouterError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

/// The type corresponding to the ConnectorRouter protocol.
#[derive(Debug)]
pub struct ConnectorRouter;

impl ::fidl_next::Discoverable for ConnectorRouter {
    const PROTOCOL_NAME: &'static str = "connector_router";
}

pub mod connector_router {
    pub mod prelude {
        pub use crate::{
            connector_router, ConnectorRouter, ConnectorRouterClientHandler,
            ConnectorRouterClientSender, ConnectorRouterServerHandler, ConnectorRouterServerSender,
        };

        pub use crate::ConnectorRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 8420527046218942310;

        type Protocol = crate::ConnectorRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireConnectorRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, connector_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> ConnectorRouterClientSender for ::fidl_next::ClientSender<___T, ConnectorRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, connector_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8420527046218942310, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the ConnectorRouter protocol.
///
/// See [`ConnectorRouter`] for more details.
pub trait ConnectorRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, ConnectorRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for ConnectorRouter
where
    ___T: ::fidl_next::Transport,
    ___H: ConnectorRouterClientHandler<___T>,

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

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

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

/// A server handler for the ConnectorRouter protocol.
///
/// See [`ConnectorRouter`] for more details.
pub trait ConnectorRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, ConnectorRouter>,

        request: ::fidl_next::Request<___T, connector_router::Route>,

        responder: ::fidl_next::Responder<connector_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, ConnectorRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for ConnectorRouter
where
    ___T: ::fidl_next::Transport,
    ___H: ConnectorRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub enum DataRouterRouteResponse {
    Data(crate::Data),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DataRouterRouteResponse {
    type Encoded = WireDataRouterRouteResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

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

            Self::Unavailable(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Unit>(value, 2, encoder, raw)?
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DataRouterRouteResponse> {
    type EncodedOption = WireOptionalDataRouterRouteResponse;
}

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

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

        Ok(())
    }
}

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

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

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

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

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

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

pub mod data_router_route_response {
    pub enum Ref<'union> {
        Data(&'union crate::WireData),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireDataRouterRouteResponse {
    pub fn as_ref(&self) -> crate::data_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::data_router_route_response::Ref::Data(unsafe {
                self.raw.get().deref_unchecked::<crate::WireData>()
            }),

            2 => crate::data_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

    ___D: ::fidl_next::Decoder,

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

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

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

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

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

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

    ___D: ::fidl_next::Decoder,

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

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

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

        Ok(())
    }
}

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

/// The type corresponding to the DataRouter protocol.
#[derive(Debug)]
pub struct DataRouter;

impl ::fidl_next::Discoverable for DataRouter {
    const PROTOCOL_NAME: &'static str = "data_router";
}

pub mod data_router {
    pub mod prelude {
        pub use crate::{
            data_router, DataRouter, DataRouterClientHandler, DataRouterClientSender,
            DataRouterServerHandler, DataRouterServerSender,
        };

        pub use crate::DataRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 3352890635970754564;

        type Protocol = crate::DataRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDataRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, data_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> DataRouterClientSender for ::fidl_next::ClientSender<___T, DataRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, data_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(3352890635970754564, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DataRouter protocol.
///
/// See [`DataRouter`] for more details.
pub trait DataRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DataRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DataRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DataRouterClientHandler<___T>,

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

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

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

/// A server handler for the DataRouter protocol.
///
/// See [`DataRouter`] for more details.
pub trait DataRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DataRouter>,

        request: ::fidl_next::Request<___T, data_router::Route>,

        responder: ::fidl_next::Responder<data_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DataRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DataRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DataRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// The type corresponding to the Dictionary protocol.
#[derive(Debug)]
pub struct Dictionary;

impl ::fidl_next::Discoverable for Dictionary {
    const PROTOCOL_NAME: &'static str = "dictionary";
}

pub mod dictionary {
    pub mod prelude {
        pub use crate::{
            dictionary, Dictionary, DictionaryClientHandler, DictionaryClientSender,
            DictionaryServerHandler, DictionaryServerSender,
        };
    }
}

/// A helper trait for the `Dictionary` client sender.
pub trait DictionaryClientSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> DictionaryClientSender for ::fidl_next::ClientSender<___T, Dictionary>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A client handler for the Dictionary protocol.
///
/// See [`Dictionary`] for more details.
pub trait DictionaryClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Dictionary>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Dictionary
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

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

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

/// A server handler for the Dictionary protocol.
///
/// See [`Dictionary`] for more details.
pub trait DictionaryServerHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Dictionary>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Dictionary
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug)]
pub struct DictionaryDrainIteratorGetNextRequest {
    pub start_id: u64,

    pub limit: u32,
}

impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest {
    type Encoded = WireDictionaryDrainIteratorGetNextRequest;
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryDrainIteratorGetNextRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryDrainIteratorGetNextRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryDrainIteratorGetNextRequest>
    for DictionaryDrainIteratorGetNextRequest
{
    #[inline]
    fn take_from(from: &WireDictionaryDrainIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::TakeFrom::take_from(&from.start_id),

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

/// The wire type corresponding to [`DictionaryDrainIteratorGetNextRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDictionaryDrainIteratorGetNextRequest {
    pub start_id: ::fidl_next::WireU64,

    pub limit: ::fidl_next::WireU32,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextRequest
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 start_id,
                mut limit,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[doc = " Maximum number of items returned by dictionary iterator.\n"]
pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128;

#[derive(Debug)]
pub struct DictionaryDrainIteratorGetNextResponse {
    pub items: Vec<crate::DictionaryItem>,

    pub end_id: u64,
}

impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse {
    type Encoded = WireDictionaryDrainIteratorGetNextResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryDrainIteratorGetNextResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryDrainIteratorGetNextResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryDrainIteratorGetNextResponse>
    for DictionaryDrainIteratorGetNextResponse
{
    #[inline]
    fn take_from(from: &WireDictionaryDrainIteratorGetNextResponse) -> Self {
        Self {
            items: ::fidl_next::TakeFrom::take_from(&from.items),

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

/// The wire type corresponding to [`DictionaryDrainIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryDrainIteratorGetNextResponse {
    pub items: ::fidl_next::WireVector<crate::WireDictionaryItem>,

    pub end_id: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextResponse
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 items,
                mut end_id,

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

/// The type corresponding to the DictionaryDrainIterator protocol.
#[derive(Debug)]
pub struct DictionaryDrainIterator;

pub mod dictionary_drain_iterator {
    pub mod prelude {
        pub use crate::{
            dictionary_drain_iterator, DictionaryDrainIterator,
            DictionaryDrainIteratorClientHandler, DictionaryDrainIteratorClientSender,
            DictionaryDrainIteratorServerHandler, DictionaryDrainIteratorServerSender,
        };

        pub use crate::CapabilityStoreError;

        pub use crate::DictionaryDrainIteratorGetNextRequest;

        pub use crate::DictionaryDrainIteratorGetNextResponse;
    }

    pub struct GetNext;

    impl ::fidl_next::Method for GetNext {
        const ORDINAL: u64 = 5728722530628427873;

        type Protocol = crate::DictionaryDrainIterator;

        type Request = crate::WireDictionaryDrainIteratorGetNextRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDictionaryDrainIteratorGetNextResponse,
            crate::WireCapabilityStoreError,
        >;
    }
}

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

    #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_drain_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDictionaryDrainIteratorGetNextRequest,
        >;
}

impl<___T> DictionaryDrainIteratorClientSender
    for ::fidl_next::ClientSender<___T, DictionaryDrainIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_drain_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDictionaryDrainIteratorGetNextRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(5728722530628427873, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DictionaryDrainIterator protocol.
///
/// See [`DictionaryDrainIterator`] for more details.
pub trait DictionaryDrainIteratorClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DictionaryDrainIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DictionaryDrainIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryDrainIteratorClientHandler<___T>,

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

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

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

/// A server handler for the DictionaryDrainIterator protocol.
///
/// See [`DictionaryDrainIterator`] for more details.
pub trait DictionaryDrainIteratorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryDrainIterator>,

        request: ::fidl_next::Request<___T, dictionary_drain_iterator::GetNext>,

        responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryDrainIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DictionaryDrainIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryDrainIteratorServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug)]
pub struct DictionaryEnumerateIteratorGetNextRequest {
    pub start_id: u64,

    pub limit: u32,
}

impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest {
    type Encoded = WireDictionaryEnumerateIteratorGetNextRequest;
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryEnumerateIteratorGetNextRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryEnumerateIteratorGetNextRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryEnumerateIteratorGetNextRequest>
    for DictionaryEnumerateIteratorGetNextRequest
{
    #[inline]
    fn take_from(from: &WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::TakeFrom::take_from(&from.start_id),

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

/// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireDictionaryEnumerateIteratorGetNextRequest {
    pub start_id: ::fidl_next::WireU64,

    pub limit: ::fidl_next::WireU32,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryEnumerateIteratorGetNextRequest
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 start_id,
                mut limit,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[doc = " A key-value pair in a [`DictionaryRef`], where the value may be elided.\n This is useful for APIs that may wish to omit the value, for example if it could not be\n duplicated.\n"]
#[derive(Debug)]
pub struct DictionaryOptionalItem {
    pub key: String,

    pub value: Option<Box<crate::WrappedCapabilityId>>,
}

impl ::fidl_next::Encodable for DictionaryOptionalItem {
    type Encoded = WireDictionaryOptionalItem;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryOptionalItem> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryOptionalItem>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryOptionalItem> for DictionaryOptionalItem {
    #[inline]
    fn take_from(from: &WireDictionaryOptionalItem) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

    pub value: ::fidl_next::WireBox<crate::WireWrappedCapabilityId>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryOptionalItem
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 key,
                mut value,

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct DictionaryEnumerateIteratorGetNextResponse {
    pub items: Vec<crate::DictionaryOptionalItem>,

    pub end_id: u64,
}

impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse {
    type Encoded = WireDictionaryEnumerateIteratorGetNextResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryEnumerateIteratorGetNextResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryEnumerateIteratorGetNextResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryEnumerateIteratorGetNextResponse>
    for DictionaryEnumerateIteratorGetNextResponse
{
    #[inline]
    fn take_from(from: &WireDictionaryEnumerateIteratorGetNextResponse) -> Self {
        Self {
            items: ::fidl_next::TakeFrom::take_from(&from.items),

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

/// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryEnumerateIteratorGetNextResponse {
    pub items: ::fidl_next::WireVector<crate::WireDictionaryOptionalItem>,

    pub end_id: ::fidl_next::WireU64,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryEnumerateIteratorGetNextResponse
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 items,
                mut end_id,

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

/// The type corresponding to the DictionaryEnumerateIterator protocol.
#[derive(Debug)]
pub struct DictionaryEnumerateIterator;

pub mod dictionary_enumerate_iterator {
    pub mod prelude {
        pub use crate::{
            dictionary_enumerate_iterator, DictionaryEnumerateIterator,
            DictionaryEnumerateIteratorClientHandler, DictionaryEnumerateIteratorClientSender,
            DictionaryEnumerateIteratorServerHandler, DictionaryEnumerateIteratorServerSender,
        };

        pub use crate::CapabilityStoreError;

        pub use crate::DictionaryEnumerateIteratorGetNextRequest;

        pub use crate::DictionaryEnumerateIteratorGetNextResponse;
    }

    pub struct GetNext;

    impl ::fidl_next::Method for GetNext {
        const ORDINAL: u64 = 1511164556663256527;

        type Protocol = crate::DictionaryEnumerateIterator;

        type Request = crate::WireDictionaryEnumerateIteratorGetNextRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDictionaryEnumerateIteratorGetNextResponse,
            crate::WireCapabilityStoreError,
        >;
    }
}

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

    #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_enumerate_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest,
        >;
}

impl<___T> DictionaryEnumerateIteratorClientSender
    for ::fidl_next::ClientSender<___T, DictionaryEnumerateIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_enumerate_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(1511164556663256527, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DictionaryEnumerateIterator protocol.
///
/// See [`DictionaryEnumerateIterator`] for more details.
pub trait DictionaryEnumerateIteratorClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DictionaryEnumerateIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DictionaryEnumerateIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryEnumerateIteratorClientHandler<___T>,

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

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

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

/// A server handler for the DictionaryEnumerateIterator protocol.
///
/// See [`DictionaryEnumerateIterator`] for more details.
pub trait DictionaryEnumerateIteratorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
    fn get_next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryEnumerateIterator>,

        request: ::fidl_next::Request<___T, dictionary_enumerate_iterator::GetNext>,

        responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryEnumerateIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DictionaryEnumerateIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryEnumerateIteratorServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum DictionaryError {
    NotFound = 1,
    AlreadyExists = 2,
    BadCapability = 3,
    InvalidKey = 4,
    NotCloneable = 5,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for DictionaryError {
    type Encoded = WireDictionaryError;
}
impl ::std::convert::From<u32> for DictionaryError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::NotFound,
            2 => Self::AlreadyExists,
            3 => Self::BadCapability,
            4 => Self::InvalidKey,
            5 => Self::NotCloneable,

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

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

            Self::AlreadyExists => 2,

            Self::BadCapability => 3,

            Self::InvalidKey => 4,

            Self::NotCloneable => 5,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDictionaryError> for DictionaryError {
    fn from(wire: WireDictionaryError) -> Self {
        match u32::from(wire.value) {
            1 => Self::NotFound,

            2 => Self::AlreadyExists,

            3 => Self::BadCapability,

            4 => Self::InvalidKey,

            5 => Self::NotCloneable,

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

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

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

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

impl WireDictionaryError {
    pub const NOT_FOUND: WireDictionaryError =
        WireDictionaryError { value: ::fidl_next::WireU32(1) };

    pub const ALREADY_EXISTS: WireDictionaryError =
        WireDictionaryError { value: ::fidl_next::WireU32(2) };

    pub const BAD_CAPABILITY: WireDictionaryError =
        WireDictionaryError { value: ::fidl_next::WireU32(3) };

    pub const INVALID_KEY: WireDictionaryError =
        WireDictionaryError { value: ::fidl_next::WireU32(4) };

    pub const NOT_CLONEABLE: WireDictionaryError =
        WireDictionaryError { value: ::fidl_next::WireU32(5) };
}

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

impl ::core::convert::From<DictionaryError> for WireDictionaryError {
    fn from(natural: DictionaryError) -> Self {
        match natural {
            DictionaryError::NotFound => WireDictionaryError::NOT_FOUND,

            DictionaryError::AlreadyExists => WireDictionaryError::ALREADY_EXISTS,

            DictionaryError::BadCapability => WireDictionaryError::BAD_CAPABILITY,

            DictionaryError::InvalidKey => WireDictionaryError::INVALID_KEY,

            DictionaryError::NotCloneable => WireDictionaryError::NOT_CLONEABLE,

            DictionaryError::UnknownOrdinal_(value) => {
                WireDictionaryError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[derive(Debug)]
pub struct DictionaryKeysIteratorGetNextResponse {
    pub keys: Vec<String>,
}

impl ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse {
    type Encoded = WireDictionaryKeysIteratorGetNextResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryKeysIteratorGetNextResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireDictionaryKeysIteratorGetNextResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryKeysIteratorGetNextResponse>
    for DictionaryKeysIteratorGetNextResponse
{
    #[inline]
    fn take_from(from: &WireDictionaryKeysIteratorGetNextResponse) -> Self {
        Self { keys: ::fidl_next::TakeFrom::take_from(&from.keys) }
    }
}

/// The wire type corresponding to [`DictionaryKeysIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryKeysIteratorGetNextResponse {
    pub keys: ::fidl_next::WireVector<::fidl_next::WireString>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryKeysIteratorGetNextResponse
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 keys,

            } = slot;
        }

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

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

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

        Ok(())
    }
}

/// The type corresponding to the DictionaryKeysIterator protocol.
#[derive(Debug)]
pub struct DictionaryKeysIterator;

pub mod dictionary_keys_iterator {
    pub mod prelude {
        pub use crate::{
            dictionary_keys_iterator, DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
            DictionaryKeysIteratorClientSender, DictionaryKeysIteratorServerHandler,
            DictionaryKeysIteratorServerSender,
        };

        pub use crate::DictionaryKeysIteratorGetNextResponse;
    }

    pub struct GetNext;

    impl ::fidl_next::Method for GetNext {
        const ORDINAL: u64 = 4987781442555247955;

        type Protocol = crate::DictionaryKeysIterator;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<crate::WireDictionaryKeysIteratorGetNextResponse>;
    }
}

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

    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_keys_iterator::GetNext>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> DictionaryKeysIteratorClientSender
    for ::fidl_next::ClientSender<___T, DictionaryKeysIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_keys_iterator::GetNext>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(4987781442555247955, &mut ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DictionaryKeysIterator protocol.
///
/// See [`DictionaryKeysIterator`] for more details.
pub trait DictionaryKeysIteratorClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DictionaryKeysIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DictionaryKeysIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryKeysIteratorClientHandler<___T>,

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

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

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

/// A server handler for the DictionaryKeysIterator protocol.
///
/// See [`DictionaryKeysIterator`] for more details.
pub trait DictionaryKeysIteratorServerHandler<___T: ::fidl_next::Transport> {
    fn get_next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryKeysIterator>,

        responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryKeysIterator>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DictionaryKeysIterator
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryKeysIteratorServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

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

                handler.get_next(sender, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub enum DictionaryRouterRouteResponse {
    Dictionary(crate::DictionaryRef),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DictionaryRouterRouteResponse {
    type Encoded = WireDictionaryRouterRouteResponse;
}

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

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

        match self {
            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::DictionaryRef,
            >(value, 1, encoder, raw)?,

            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Unit,
            >(value, 2, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DictionaryRouterRouteResponse> {
    type EncodedOption = WireOptionalDictionaryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDictionaryRouterRouteResponse> for DictionaryRouterRouteResponse {
    #[inline]
    fn take_from(from: &WireDictionaryRouterRouteResponse) -> Self {
        match from.raw.ordinal() {
            1 => Self::Dictionary(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
            })),

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

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

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

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

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

pub mod dictionary_router_route_response {
    pub enum Ref<'union> {
        Dictionary(&'union crate::WireDictionaryRef),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireDictionaryRouterRouteResponse {
    pub fn as_ref(&self) -> crate::dictionary_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::dictionary_router_route_response::Ref::Dictionary(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
            }),

            2 => crate::dictionary_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

/// The type corresponding to the DictionaryRouter protocol.
#[derive(Debug)]
pub struct DictionaryRouter;

impl ::fidl_next::Discoverable for DictionaryRouter {
    const PROTOCOL_NAME: &'static str = "dictionary_router";
}

pub mod dictionary_router {
    pub mod prelude {
        pub use crate::{
            dictionary_router, DictionaryRouter, DictionaryRouterClientHandler,
            DictionaryRouterClientSender, DictionaryRouterServerHandler,
            DictionaryRouterServerSender,
        };

        pub use crate::DictionaryRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 8164012099375978399;

        type Protocol = crate::DictionaryRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDictionaryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> DictionaryRouterClientSender for ::fidl_next::ClientSender<___T, DictionaryRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dictionary_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8164012099375978399, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DictionaryRouter protocol.
///
/// See [`DictionaryRouter`] for more details.
pub trait DictionaryRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DictionaryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DictionaryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryRouterClientHandler<___T>,

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

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

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

/// A server handler for the DictionaryRouter protocol.
///
/// See [`DictionaryRouter`] for more details.
pub trait DictionaryRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryRouter>,

        request: ::fidl_next::Request<___T, dictionary_router::Route>,

        responder: ::fidl_next::Responder<dictionary_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DictionaryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DictionaryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DictionaryRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub enum DirConnectorRouterRouteResponse {
    DirConnector(crate::DirConnector),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DirConnectorRouterRouteResponse {
    type Encoded = WireDirConnectorRouterRouteResponse;
}

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

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

        match self {
            Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::DirConnector,
            >(value, 1, encoder, raw)?,

            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Unit,
            >(value, 2, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirConnectorRouterRouteResponse> {
    type EncodedOption = WireOptionalDirConnectorRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirConnectorRouterRouteResponse>
    for DirConnectorRouterRouteResponse
{
    #[inline]
    fn take_from(from: &WireDirConnectorRouterRouteResponse) -> Self {
        match from.raw.ordinal() {
            1 => Self::DirConnector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirConnector>()
            })),

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

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

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

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

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

pub mod dir_connector_router_route_response {
    pub enum Ref<'union> {
        DirConnector(&'union crate::WireDirConnector),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireDirConnectorRouterRouteResponse {
    pub fn as_ref(&self) -> crate::dir_connector_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::dir_connector_router_route_response::Ref::DirConnector(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirConnector>()
            }),

            2 => crate::dir_connector_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

/// The type corresponding to the DirConnectorRouter protocol.
#[derive(Debug)]
pub struct DirConnectorRouter;

impl ::fidl_next::Discoverable for DirConnectorRouter {
    const PROTOCOL_NAME: &'static str = "dir_connector_router";
}

pub mod dir_connector_router {
    pub mod prelude {
        pub use crate::{
            dir_connector_router, DirConnectorRouter, DirConnectorRouterClientHandler,
            DirConnectorRouterClientSender, DirConnectorRouterServerHandler,
            DirConnectorRouterServerSender,
        };

        pub use crate::DirConnectorRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 972231070188342848;

        type Protocol = crate::DirConnectorRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDirConnectorRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dir_connector_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> DirConnectorRouterClientSender for ::fidl_next::ClientSender<___T, DirConnectorRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dir_connector_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(972231070188342848, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DirConnectorRouter protocol.
///
/// See [`DirConnectorRouter`] for more details.
pub trait DirConnectorRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DirConnectorRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DirConnectorRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirConnectorRouterClientHandler<___T>,

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

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

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

/// A server handler for the DirConnectorRouter protocol.
///
/// See [`DirConnectorRouter`] for more details.
pub trait DirConnectorRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirConnectorRouter>,

        request: ::fidl_next::Request<___T, dir_connector_router::Route>,

        responder: ::fidl_next::Responder<dir_connector_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirConnectorRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DirConnectorRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirConnectorRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub enum DirEntryRouterRouteResponse {
    DirEntry(crate::DirEntry),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DirEntryRouterRouteResponse {
    type Encoded = WireDirEntryRouterRouteResponse;
}

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

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

        match self {
            Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::DirEntry,
            >(value, 1, encoder, raw)?,

            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Unit,
            >(value, 2, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirEntryRouterRouteResponse> {
    type EncodedOption = WireOptionalDirEntryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirEntryRouterRouteResponse> for DirEntryRouterRouteResponse {
    #[inline]
    fn take_from(from: &WireDirEntryRouterRouteResponse) -> Self {
        match from.raw.ordinal() {
            1 => Self::DirEntry(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDirEntry>()
            })),

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

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

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

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

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

pub mod dir_entry_router_route_response {
    pub enum Ref<'union> {
        DirEntry(&'union crate::WireDirEntry),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireDirEntryRouterRouteResponse {
    pub fn as_ref(&self) -> crate::dir_entry_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::dir_entry_router_route_response::Ref::DirEntry(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirEntry>()
            }),

            2 => crate::dir_entry_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

/// The type corresponding to the DirEntryRouter protocol.
#[derive(Debug)]
pub struct DirEntryRouter;

impl ::fidl_next::Discoverable for DirEntryRouter {
    const PROTOCOL_NAME: &'static str = "dir_entry_router";
}

pub mod dir_entry_router {
    pub mod prelude {
        pub use crate::{
            dir_entry_router, DirEntryRouter, DirEntryRouterClientHandler,
            DirEntryRouterClientSender, DirEntryRouterServerHandler, DirEntryRouterServerSender,
        };

        pub use crate::DirEntryRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 1929392218567642066;

        type Protocol = crate::DirEntryRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDirEntryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dir_entry_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> DirEntryRouterClientSender for ::fidl_next::ClientSender<___T, DirEntryRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, dir_entry_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(1929392218567642066, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DirEntryRouter protocol.
///
/// See [`DirEntryRouter`] for more details.
pub trait DirEntryRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DirEntryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DirEntryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirEntryRouterClientHandler<___T>,

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

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

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

/// A server handler for the DirEntryRouter protocol.
///
/// See [`DirEntryRouter`] for more details.
pub trait DirEntryRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirEntryRouter>,

        request: ::fidl_next::Request<___T, dir_entry_router::Route>,

        responder: ::fidl_next::Responder<dir_entry_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirEntryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DirEntryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirEntryRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirReceiverReceiveRequest {
    pub channel: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::zx::Channel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

    type Encoded = WireDirReceiverReceiveRequest;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirReceiverReceiveRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDirReceiverReceiveRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirReceiverReceiveRequest> for DirReceiverReceiveRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                ::fidl_next::fuchsia::zx::Channel,
                ::fidl_next_fuchsia_io::Directory,
            > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`DirReceiverReceiveRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirReceiverReceiveRequest {
    pub channel: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirReceiverReceiveRequest
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 channel,

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the DirReceiver protocol.
#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
#[derive(Debug)]
pub struct DirReceiver;

impl ::fidl_next::Discoverable for DirReceiver {
    const PROTOCOL_NAME: &'static str = "dir_receiver";
}

pub mod dir_receiver {
    pub mod prelude {
        pub use crate::{
            dir_receiver, DirReceiver, DirReceiverClientHandler, DirReceiverClientSender,
            DirReceiverServerHandler, DirReceiverServerSender,
        };

        pub use crate::DirReceiverReceiveRequest;
    }

    pub struct Receive;

    impl ::fidl_next::Method for Receive {
        const ORDINAL: u64 = 926684461087488948;

        type Protocol = crate::DirReceiver;

        type Request = crate::WireDirReceiverReceiveRequest;

        type Response = ::fidl_next::Never;
    }
}

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

    #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
    fn receive<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirReceiverReceiveRequest,
        >;
}

impl<___T> DirReceiverClientSender for ::fidl_next::ClientSender<___T, DirReceiver>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
    fn receive<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDirReceiverReceiveRequest,
        >,
    {
        self.as_untyped().send_one_way(926684461087488948, request)
    }
}

/// A client handler for the DirReceiver protocol.
///
/// See [`DirReceiver`] for more details.
pub trait DirReceiverClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DirReceiver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DirReceiver
where
    ___T: ::fidl_next::Transport,
    ___H: DirReceiverClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

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

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

/// A server handler for the DirReceiver protocol.
///
/// See [`DirReceiver`] for more details.
pub trait DirReceiverServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
    fn receive(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirReceiver>,

        request: ::fidl_next::Request<___T, dir_receiver::Receive>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirReceiver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DirReceiver
where
    ___T: ::fidl_next::Transport,
    ___H: DirReceiverServerHandler<___T>,

    crate::WireDirReceiverReceiveRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.receive(sender, decoded),
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
pub enum DirectoryRouterRouteResponse {
    Directory(
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    ),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DirectoryRouterRouteResponse {
    type Encoded = WireDirectoryRouterRouteResponse;
}

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

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

        match self {
            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                ::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::zx::Channel,
                    ::fidl_next_fuchsia_io::Directory,
                >,
            >(value, 1, encoder, raw)?,

            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                crate::Unit,
            >(value, 2, encoder, raw)?,
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DirectoryRouterRouteResponse> {
    type EncodedOption = WireOptionalDirectoryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDirectoryRouterRouteResponse> for DirectoryRouterRouteResponse {
    #[inline]
    fn take_from(from: &WireDirectoryRouterRouteResponse) -> Self {
        match from.raw.ordinal() {
            1 => Self::Directory(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >>()
            })),

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

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

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

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

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

pub mod directory_router_route_response {
    pub enum Ref<'union> {
        Directory(
            &'union ::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Directory,
            >,
        ),

        Unavailable(&'union crate::WireUnit),
    }
}

impl WireDirectoryRouterRouteResponse {
    pub fn as_ref(&self) -> crate::directory_router_route_response::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::directory_router_route_response::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next::fuchsia::WireChannel,
                    ::fidl_next_fuchsia_io::Directory,
                >>()
            }),

            2 => crate::directory_router_route_response::Ref::Unavailable(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnit>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireDirectoryRouterRouteResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_io::Directory,
                    >>()
                    .fmt(f)
            },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}

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

/// The type corresponding to the DirectoryRouter protocol.
#[derive(Debug)]
pub struct DirectoryRouter;

impl ::fidl_next::Discoverable for DirectoryRouter {
    const PROTOCOL_NAME: &'static str = "directory_router";
}

pub mod directory_router {
    pub mod prelude {
        pub use crate::{
            directory_router, DirectoryRouter, DirectoryRouterClientHandler,
            DirectoryRouterClientSender, DirectoryRouterServerHandler, DirectoryRouterServerSender,
        };

        pub use crate::DirectoryRouterRouteResponse;

        pub use crate::RouteRequest;

        pub use crate::RouterError;
    }

    pub struct Route;

    impl ::fidl_next::Method for Route {
        const ORDINAL: u64 = 7510716014181158689;

        type Protocol = crate::DirectoryRouter;

        type Request = crate::WireRouteRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireDirectoryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }
}

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

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >;
}

impl<___T> DirectoryRouterClientSender for ::fidl_next::ClientSender<___T, DirectoryRouter>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn route<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, directory_router::Route>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRouteRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(7510716014181158689, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the DirectoryRouter protocol.
///
/// See [`DirectoryRouter`] for more details.
pub trait DirectoryRouterClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, DirectoryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for DirectoryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryRouterClientHandler<___T>,

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

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

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

/// A server handler for the DirectoryRouter protocol.
///
/// See [`DirectoryRouter`] for more details.
pub trait DirectoryRouterServerHandler<___T: ::fidl_next::Transport> {
    fn route(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirectoryRouter>,

        request: ::fidl_next::Request<___T, directory_router::Route>,

        responder: ::fidl_next::Responder<directory_router::Route>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, DirectoryRouter>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for DirectoryRouter
where
    ___T: ::fidl_next::Transport,
    ___H: DirectoryRouterServerHandler<___T>,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[doc = " Contains a protocol open request.\n"]
#[derive(Debug)]
#[repr(C)]
pub struct ProtocolPayload {
    pub channel: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireProtocolPayload;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ProtocolPayload> {
    type EncodedOption = ::fidl_next::WireBox<WireProtocolPayload>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireProtocolPayload> for ProtocolPayload {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`ProtocolPayload`].
#[derive(Debug)]
#[repr(C)]
pub struct WireProtocolPayload {
    pub channel: ::fidl_next::fuchsia::WireHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireProtocolPayload
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 channel,

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Receiver protocol.
#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
#[derive(Debug)]
pub struct Receiver;

impl ::fidl_next::Discoverable for Receiver {
    const PROTOCOL_NAME: &'static str = "receiver";
}

pub mod receiver {
    pub mod prelude {
        pub use crate::{
            receiver, Receiver, ReceiverClientHandler, ReceiverClientSender, ReceiverServerHandler,
            ReceiverServerSender,
        };

        pub use crate::ProtocolPayload;
    }

    pub struct Receive;

    impl ::fidl_next::Method for Receive {
        const ORDINAL: u64 = 340832707723008660;

        type Protocol = crate::Receiver;

        type Request = crate::WireProtocolPayload;

        type Response = ::fidl_next::Never;
    }
}

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

    #[doc = " Sends a channel to this receiver.\n"]
    fn receive<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireProtocolPayload,
        >;
}

impl<___T> ReceiverClientSender for ::fidl_next::ClientSender<___T, Receiver>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Sends a channel to this receiver.\n"]
    fn receive<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireProtocolPayload,
        >,
    {
        self.as_untyped().send_one_way(340832707723008660, request)
    }
}

/// A client handler for the Receiver protocol.
///
/// See [`Receiver`] for more details.
pub trait ReceiverClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Receiver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Receiver
where
    ___T: ::fidl_next::Transport,
    ___H: ReceiverClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

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

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

/// A server handler for the Receiver protocol.
///
/// See [`Receiver`] for more details.
pub trait ReceiverServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Sends a channel to this receiver.\n"]
    fn receive(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Receiver>,

        request: ::fidl_next::Request<___T, receiver::Receive>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Receiver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Receiver
where
    ___T: ::fidl_next::Transport,
    ___H: ReceiverServerHandler<___T>,

    crate::WireProtocolPayload: ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.receive(sender, decoded),
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct Unavailable {}

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

    type Encoded = WireUnavailable;
}

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

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<Unavailable> {
    type EncodedOption = ::fidl_next::WireBox<WireUnavailable>;
}

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

        Ok(())
    }
}

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnavailable
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(())
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::fidl_next::TakeFrom<crate::WireAvailability>
        for ::fidl_fuchsia_component_sandbox::Availability
    {
        #[inline]
        fn take_from(from: &crate::WireAvailability) -> Self {
            match crate::Availability::from(*from) {
                crate::Availability::Required => Self::Required,

                crate::Availability::Optional => Self::Optional,

                crate::Availability::SameAsTarget => Self::SameAsTarget,

                crate::Availability::Transitional => Self::Transitional,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUnit> for ::fidl_fuchsia_component_sandbox::Unit {
        #[inline]
        fn take_from(from: &crate::WireUnit) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireData> for ::fidl_fuchsia_component_sandbox::Data {
        #[inline]
        fn take_from(from: &crate::WireData) -> Self {
            match from.as_ref() {
                crate::data::Ref::Bytes(value) => {
                    Self::Bytes(::fidl_next::TakeFrom::take_from(value))
                }

                crate::data::Ref::String(value) => {
                    Self::String(::fidl_next::TakeFrom::take_from(value))
                }

                crate::data::Ref::Int64(value) => {
                    Self::Int64(::fidl_next::TakeFrom::take_from(value))
                }

                crate::data::Ref::Uint64(value) => {
                    Self::Uint64(::fidl_next::TakeFrom::take_from(value))
                }

                crate::data::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireDictionaryRef>
        for ::fidl_fuchsia_component_sandbox::DictionaryRef
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryRef) -> Self {
            Self { token: ::fidl_next::TakeFrom::take_from(&from.token) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConnector> for ::fidl_fuchsia_component_sandbox::Connector {
        #[inline]
        fn take_from(from: &crate::WireConnector) -> Self {
            Self { token: ::fidl_next::TakeFrom::take_from(&from.token) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirConnector>
        for ::fidl_fuchsia_component_sandbox::DirConnector
    {
        #[inline]
        fn take_from(from: &crate::WireDirConnector) -> Self {
            Self { token: ::fidl_next::TakeFrom::take_from(&from.token) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
        #[inline]
        fn take_from(from: &crate::WireDirEntry) -> Self {
            Self { token: ::fidl_next::TakeFrom::take_from(&from.token) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapability> for ::fidl_fuchsia_component_sandbox::Capability {
        #[inline]
        fn take_from(from: &crate::WireCapability) -> Self {
            match from.as_ref() {
                crate::capability::Ref::Unit(value) => {
                    Self::Unit(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Handle(value) => {
                    Self::Handle(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Data(value) => {
                    Self::Data(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Dictionary(value) => {
                    Self::Dictionary(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Connector(value) => {
                    Self::Connector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DirConnector(value) => {
                    Self::DirConnector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DirEntry(value) => {
                    Self::DirEntry(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::ConnectorRouter(value) => {
                    Self::ConnectorRouter(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DictionaryRouter(value) => {
                    Self::DictionaryRouter(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DirEntryRouter(value) => {
                    Self::DirEntryRouter(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DataRouter(value) => {
                    Self::DataRouter(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::DirConnectorRouter(value) => {
                    Self::DirConnectorRouter(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDuplicateRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDuplicateRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreError>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreError) -> Self {
            match crate::CapabilityStoreError::from(*from) {
                crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,

                crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,

                crate::CapabilityStoreError::BadCapability => Self::BadCapability,

                crate::CapabilityStoreError::WrongType => Self::WrongType,

                crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,

                crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,

                crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,

                crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,

                crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,

                crate::CapabilityStoreError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDropRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDropRequest) -> Self {
            Self { id: ::fidl_next::TakeFrom::take_from(&from.id) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreExportRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreExportRequest) -> Self {
            Self { id: ::fidl_next::TakeFrom::take_from(&from.id) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreExportResponse>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreExportResponse) -> Self {
            Self { capability: ::fidl_next::TakeFrom::take_from(&from.capability) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreImportRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreImportRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreConnectorCreateRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreConnectorCreateRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreConnectorOpenRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreConnectorOpenRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDirConnectorCreateRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDirConnectorCreateRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDirConnectorOpenRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDirConnectorOpenRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryCreateRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryCreateRequest) -> Self {
            Self { id: ::fidl_next::TakeFrom::take_from(&from.id) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryLegacyImportRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryLegacyImportRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryLegacyExportRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryLegacyExportRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireDictionaryItem>
        for ::fidl_fuchsia_component_sandbox::DictionaryItem
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryItem) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryInsertRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryInsertRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryGetRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryGetRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

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

    impl ::fidl_next::TakeFrom<crate::WireWrappedCapabilityId>
        for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
    {
        #[inline]
        fn take_from(from: &crate::WireWrappedCapabilityId) -> Self {
            Self { id: ::fidl_next::TakeFrom::take_from(&from.id) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryRemoveRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryRemoveRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryCopyRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryCopyRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryKeysRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryKeysRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryEnumerateRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryEnumerateRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    impl ::fidl_next::TakeFrom<crate::WireCapabilityStoreDictionaryDrainRequest>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityStoreDictionaryDrainRequest) -> Self {
            Self {
                id: ::fidl_next::TakeFrom::take_from(&from.id),

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `CapabilityStore`
    /// protocol.
    pub type CapabilityStoreProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::CapabilityStore>;

    impl ::fidl_next::TakeFrom<crate::CapabilityStore>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
    {
        #[inline]
        fn take_from(from: &crate::CapabilityStore) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireInstanceToken>
        for ::fidl_fuchsia_component_sandbox::InstanceToken
    {
        #[inline]
        fn take_from(from: &crate::WireInstanceToken) -> Self {
            Self { token: ::fidl_next::TakeFrom::take_from(&from.token) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRouteRequest>
        for ::fidl_fuchsia_component_sandbox::RouteRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRouteRequest) -> Self {
            Self {
                requesting: from.requesting().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConnectorRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireConnectorRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::connector_router_route_response::Ref::Connector(value) => {
                    Self::Connector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::connector_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireRouterError>
        for ::fidl_fuchsia_component_sandbox::RouterError
    {
        #[inline]
        fn take_from(from: &crate::WireRouterError) -> Self {
            match crate::RouterError::from(*from) {
                crate::RouterError::NotFound => Self::NotFound,

                crate::RouterError::InvalidArgs => Self::InvalidArgs,

                crate::RouterError::NotSupported => Self::NotSupported,

                crate::RouterError::Internal => Self::Internal,

                crate::RouterError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `ConnectorRouter`
    /// protocol.
    pub type ConnectorRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::ConnectorRouter>;

    impl ::fidl_next::TakeFrom<crate::ConnectorRouter>
        for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::ConnectorRouter) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDataRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDataRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::data_router_route_response::Ref::Data(value) => {
                    Self::Data(::fidl_next::TakeFrom::take_from(value))
                }

                crate::data_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DataRouter`
    /// protocol.
    pub type DataRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DataRouter>;

    impl ::fidl_next::TakeFrom<crate::DataRouter>
        for ::fidl_fuchsia_component_sandbox::DataRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::DataRouter) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Dictionary`
    /// protocol.
    pub type DictionaryProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Dictionary>;

    impl ::fidl_next::TakeFrom<crate::Dictionary>
        for ::fidl_fuchsia_component_sandbox::DictionaryMarker
    {
        #[inline]
        fn take_from(from: &crate::Dictionary) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionaryDrainIteratorGetNextRequest>
        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryDrainIteratorGetNextRequest) -> Self {
            Self {
                start_id: ::fidl_next::TakeFrom::take_from(&from.start_id),

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

    impl ::fidl_next::TakeFrom<crate::WireDictionaryDrainIteratorGetNextResponse>
        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryDrainIteratorGetNextResponse) -> Self {
            Self {
                items: ::fidl_next::TakeFrom::take_from(&from.items),

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DictionaryDrainIterator`
    /// protocol.
    pub type DictionaryDrainIteratorProxy = ::fidl_next::ClientSender<
        ::fidl_next::fuchsia::zx::Channel,
        crate::DictionaryDrainIterator,
    >;

    impl ::fidl_next::TakeFrom<crate::DictionaryDrainIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
    {
        #[inline]
        fn take_from(from: &crate::DictionaryDrainIterator) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionaryEnumerateIteratorGetNextRequest>
        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
            Self {
                start_id: ::fidl_next::TakeFrom::take_from(&from.start_id),

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

    impl ::fidl_next::TakeFrom<crate::WireDictionaryOptionalItem>
        for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryOptionalItem) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

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

    impl ::fidl_next::TakeFrom<crate::WireDictionaryEnumerateIteratorGetNextResponse>
        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryEnumerateIteratorGetNextResponse) -> Self {
            Self {
                items: ::fidl_next::TakeFrom::take_from(&from.items),

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DictionaryEnumerateIterator`
    /// protocol.
    pub type DictionaryEnumerateIteratorProxy = ::fidl_next::ClientSender<
        ::fidl_next::fuchsia::zx::Channel,
        crate::DictionaryEnumerateIterator,
    >;

    impl ::fidl_next::TakeFrom<crate::DictionaryEnumerateIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
    {
        #[inline]
        fn take_from(from: &crate::DictionaryEnumerateIterator) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionaryError>
        for ::fidl_fuchsia_component_sandbox::DictionaryError
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryError) -> Self {
            match crate::DictionaryError::from(*from) {
                crate::DictionaryError::NotFound => Self::NotFound,

                crate::DictionaryError::AlreadyExists => Self::AlreadyExists,

                crate::DictionaryError::BadCapability => Self::BadCapability,

                crate::DictionaryError::InvalidKey => Self::InvalidKey,

                crate::DictionaryError::NotCloneable => Self::NotCloneable,

                crate::DictionaryError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionaryKeysIteratorGetNextResponse>
        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryKeysIteratorGetNextResponse) -> Self {
            Self { keys: ::fidl_next::TakeFrom::take_from(&from.keys) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DictionaryKeysIterator`
    /// protocol.
    pub type DictionaryKeysIteratorProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DictionaryKeysIterator>;

    impl ::fidl_next::TakeFrom<crate::DictionaryKeysIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
    {
        #[inline]
        fn take_from(from: &crate::DictionaryKeysIterator) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionaryRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDictionaryRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::dictionary_router_route_response::Ref::Dictionary(value) => {
                    Self::Dictionary(::fidl_next::TakeFrom::take_from(value))
                }

                crate::dictionary_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DictionaryRouter`
    /// protocol.
    pub type DictionaryRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DictionaryRouter>;

    impl ::fidl_next::TakeFrom<crate::DictionaryRouter>
        for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::DictionaryRouter) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirConnectorRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirConnectorRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::dir_connector_router_route_response::Ref::DirConnector(value) => {
                    Self::DirConnector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::dir_connector_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DirConnectorRouter`
    /// protocol.
    pub type DirConnectorRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DirConnectorRouter>;

    impl ::fidl_next::TakeFrom<crate::DirConnectorRouter>
        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::DirConnectorRouter) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirEntryRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirEntryRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::dir_entry_router_route_response::Ref::DirEntry(value) => {
                    Self::DirEntry(::fidl_next::TakeFrom::take_from(value))
                }

                crate::dir_entry_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DirEntryRouter`
    /// protocol.
    pub type DirEntryRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DirEntryRouter>;

    impl ::fidl_next::TakeFrom<crate::DirEntryRouter>
        for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::DirEntryRouter) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirReceiverReceiveRequest>
        for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDirReceiverReceiveRequest) -> Self {
            Self { channel: ::fidl_next::TakeFrom::take_from(&from.channel) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DirReceiver`
    /// protocol.
    pub type DirReceiverProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DirReceiver>;

    impl ::fidl_next::TakeFrom<crate::DirReceiver>
        for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
    {
        #[inline]
        fn take_from(from: &crate::DirReceiver) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectoryRouterRouteResponse>
        for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
    {
        #[inline]
        fn take_from(from: &crate::WireDirectoryRouterRouteResponse) -> Self {
            match from.as_ref() {
                crate::directory_router_route_response::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::directory_router_route_response::Ref::Unavailable(value) => {
                    Self::Unavailable(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `DirectoryRouter`
    /// protocol.
    pub type DirectoryRouterProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::DirectoryRouter>;

    impl ::fidl_next::TakeFrom<crate::DirectoryRouter>
        for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
    {
        #[inline]
        fn take_from(from: &crate::DirectoryRouter) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireProtocolPayload>
        for ::fidl_fuchsia_component_sandbox::ProtocolPayload
    {
        #[inline]
        fn take_from(from: &crate::WireProtocolPayload) -> Self {
            Self { channel: ::fidl_next::TakeFrom::take_from(&from.channel) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Receiver`
    /// protocol.
    pub type ReceiverProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Receiver>;

    impl ::fidl_next::TakeFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
        #[inline]
        fn take_from(from: &crate::Receiver) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUnavailable>
        for ::fidl_fuchsia_component_sandbox::Unavailable
    {
        #[inline]
        fn take_from(from: &crate::WireUnavailable) -> Self {
            Self {}
        }
    }
}