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

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Availability
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::FromWire<WireAvailability> for Availability {
    #[inline]
    fn from_wire(wire: WireAvailability) -> Self {
        Self::from(wire)
    }
}

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

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

    #[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, WireUnit> =
        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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

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

            } = out;
        }

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

            3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireI64>()
            })),

            4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireU64>()
            })),

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

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

            2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
            })),

            3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireI64>()
            })),

            4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireU64>()
            })),

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

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

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

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

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

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

            3 => {
                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI64>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU64>() };
            }

            _ => (),
        }
    }
}

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

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

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

        String(&'de ::fidl_next::WireString<'de>),

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

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireData<'de> {
    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<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

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

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
                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<'de> ::core::fmt::Debug for WireData<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
            },
            2 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

impl<'de> WireOptionalData<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

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

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
                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<'de> ::core::fmt::Debug for WireOptionalData<'de> {
    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, WireDictionaryRef> = 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(
        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(self.token, encoder, token)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::Wire for WireDirEntry {
    type Decoded<'de> = 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_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    ),

    DirEntry(crate::DirEntry),

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

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

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

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

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

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Capability {
    type Encoded = WireCapability<'static>;
}

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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireCapability { raw, _phantom: _ } = 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_io::Directory,
                    ::fidl_next::fuchsia::zx::Channel,
                >,
            >(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<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
            >(value, 9, encoder, raw)?,

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

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

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

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

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

        Ok(())
    }
}

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

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

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

        Ok(())
    }
}

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

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

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

            4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
            })),

            5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConnector>()
            })),

            6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirConnector>()
            })),

            7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            })),

            8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirEntry>()
            })),

            9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                    crate::ConnectorRouter,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            })),

            10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                    crate::DictionaryRouter,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            })),

            11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>>()
            })),

            12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
            })),

            13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                    crate::DirConnectorRouter,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            })),

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

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

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

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

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

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

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

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

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

            7 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next_fuchsia_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

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

            9 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        crate::ConnectorRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

            10 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        crate::DictionaryRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

            11 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        crate::DirEntryRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

            12 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
                };
            }

            13 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        crate::DirConnectorRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

            _ => (),
        }
    }
}

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

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

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

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

        Data(&'de crate::WireData<'de>),

        Dictionary(&'de crate::WireDictionaryRef),

        Connector(&'de crate::WireConnector),

        DirConnector(&'de crate::WireDirConnector),

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

        DirEntry(&'de crate::WireDirEntry),

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

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

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

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

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireCapability<'de> {
    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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            }),

            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<
                    crate::ConnectorRouter,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            }),

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

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

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

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::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<'static>>(
                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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >(raw, decoder)?,

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

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

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

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

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

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireCapability<'de> {
    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_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                    .fmt(f)
            },
            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
            9 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        crate::ConnectorRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                    .fmt(f)
            },
            10 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        crate::DictionaryRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                    .fmt(f)
            },
            11 => unsafe {
                self.raw.get().deref_unchecked::<
                            ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>
                        >().fmt(f)
            },
            12 => unsafe {
                self.raw.get().deref_unchecked::<
                            ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
                        >().fmt(f)
            },
            13 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::ClientEnd<
                        crate::DirConnectorRouter,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                    .fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalCapability<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

impl<'de> WireOptionalCapability<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::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<'static>>(
                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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >(raw, decoder)?,

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

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

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

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

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

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalCapability<'de> {
    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,
        WireCapabilityStoreDuplicateRequest,
    > = 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(
        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(self.id, encoder, id)?;

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

        Ok(())
    }
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

impl ::fidl_next::FromWireRef<WireCapabilityStoreDuplicateRequest>
    for CapabilityStoreDuplicateRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireCapabilityStoreDuplicateRequest) -> Self {
        Self {
            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),

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

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::FromWire<WireCapabilityStoreError> for CapabilityStoreError {
    #[inline]
    fn from_wire(wire: WireCapabilityStoreError) -> Self {
        Self::from(wire)
    }
}

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

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

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

        Ok(())
    }
}

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

impl ::fidl_next::FromWireRef<WireCapabilityStoreDropRequest> for CapabilityStoreDropRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCapabilityStoreDropRequest) -> Self {
        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
    }
}

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

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

        Ok(())
    }
}

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

impl ::fidl_next::FromWireRef<WireCapabilityStoreExportRequest> for CapabilityStoreExportRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCapabilityStoreExportRequest) -> Self {
        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
    }
}

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireCapabilityStoreExportResponse<'de>>
    for CapabilityStoreExportResponse
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreExportResponse<'de>) -> Self {
        Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
    }
}

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

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireCapabilityStoreImportRequest<'de>>
    for CapabilityStoreImportRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreImportRequest<'de>) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

    pub capability: crate::WireCapability<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreConnectorCreateRequest>
    for CapabilityStoreConnectorCreateRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreConnectorCreateRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreConnectorOpenRequest>
    for CapabilityStoreConnectorOpenRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreConnectorOpenRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

            server_end: ::fidl_next::FromWire::from_wire(wire.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::Wire for WireCapabilityStoreConnectorOpenRequest {
    type Decoded<'de> = 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<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorCreateRequest>
    for CapabilityStoreDirConnectorCreateRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDirConnectorCreateRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

unsafe impl ::fidl_next::Wire for WireCapabilityStoreDirConnectorCreateRequest {
    type Decoded<'de> = 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_io::Directory,
        ::fidl_next::fuchsia::zx::Channel,
    >,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorOpenRequest>
    for CapabilityStoreDirConnectorOpenRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDirConnectorOpenRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

            server_end: ::fidl_next::FromWire::from_wire(wire.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_io::Directory,
        ::fidl_next::fuchsia::WireChannel,
    >,
}

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

        Ok(())
    }
}

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCreateRequest>
    for CapabilityStoreDictionaryCreateRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCreateRequest) -> Self {
        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
    }
}

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyImportRequest>
    for CapabilityStoreDictionaryLegacyImportRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryLegacyImportRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

            client_end: ::fidl_next::FromWire::from_wire(wire.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::Wire for WireCapabilityStoreDictionaryLegacyImportRequest {
    type Decoded<'de> = 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(
        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(self.id, encoder, id)?;

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyExportRequest>
    for CapabilityStoreDictionaryLegacyExportRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryLegacyExportRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDictionaryItem<'de>> for DictionaryItem {
    #[inline]
    fn from_wire(wire: WireDictionaryItem<'de>) -> Self {
        Self {
            key: ::fidl_next::FromWire::from_wire(wire.key),

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

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

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

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

    pub value: ::fidl_next::WireU64,
}

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

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

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

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryInsertRequest<'de>>
    for CapabilityStoreDictionaryInsertRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryInsertRequest<'de>) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

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

    pub item: crate::WireDictionaryItem<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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<'static>;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryGetRequest<'de>>
    for CapabilityStoreDictionaryGetRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryGetRequest<'de>) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

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

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

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

    pub key: ::fidl_next::WireString<'de>,

    pub dest_id: ::fidl_next::WireU64,
}

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

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

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

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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, WireWrappedCapabilityId> = 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(
        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(self.id, encoder, id)?;

        Ok(())
    }
}

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

impl ::fidl_next::FromWireRef<WireWrappedCapabilityId> for WrappedCapabilityId {
    #[inline]
    fn from_wire_ref(wire: &WireWrappedCapabilityId) -> Self {
        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
    }
}

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

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

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryRemoveRequest<'de>>
    for CapabilityStoreDictionaryRemoveRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

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

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

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

    pub key: ::fidl_next::WireString<'de>,

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

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

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

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

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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,
        WireCapabilityStoreDictionaryCopyRequest,
    > = 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(
        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(self.id, encoder, id)?;

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

        Ok(())
    }
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCopyRequest>
    for CapabilityStoreDictionaryCopyRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCopyRequest) -> Self {
        Self {
            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),

            dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireCapabilityStoreDictionaryCopyRequest {
    type Decoded<'de> = 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<crate::DictionaryKeysIterator, ::fidl_next::fuchsia::zx::Channel>,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryKeysRequest>
    for CapabilityStoreDictionaryKeysRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryKeysRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryKeysRequest {
    type Decoded<'de> = 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<
        crate::DictionaryEnumerateIterator,
        ::fidl_next::fuchsia::zx::Channel,
    >,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryEnumerateRequest>
    for CapabilityStoreDictionaryEnumerateRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryEnumerateRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryEnumerateRequest {
    type Decoded<'de> = 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: Option<
        ::fidl_next::ServerEnd<crate::DictionaryDrainIterator, ::fidl_next::fuchsia::zx::Channel>,
    >,
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryDrainRequest>
    for CapabilityStoreDictionaryDrainRequest
{
    #[inline]
    fn from_wire(wire: WireCapabilityStoreDictionaryDrainRequest) -> Self {
        Self {
            id: ::fidl_next::FromWire::from_wire(wire.id),

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

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

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

unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryDrainRequest {
    type Decoded<'de> = 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 = "fuchsia.component.sandbox.CapabilityStore";
}

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

        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<
            'static,
            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<
            'static,
            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<
            'static,
            crate::WireCapabilityStoreExportResponse<'static>,
            crate::WireCapabilityStoreError,
        >;
    }

    pub struct Import;

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

        type Protocol = crate::CapabilityStore;

        type Request = crate::WireCapabilityStoreImportRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            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<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            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<
            'static,
            crate::WireCapabilityStoreDictionaryDrainResponse,
            crate::WireCapabilityStoreError,
        >;
    }

    mod ___detail {

        pub struct Duplicate<T0, T1> {
            id: T0,

            dest_id: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Duplicate<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreDuplicateRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct Drop<T0> {
            id: T0,
        }

        impl<T0> ::fidl_next::Encodable for Drop<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreDropRequest;
        }

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

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

                    } = out;
                }

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

                Ok(())
            }
        }

        pub struct Export<T0> {
            id: T0,
        }

        impl<T0> ::fidl_next::Encodable for Export<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreExportRequest;
        }

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

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

                    } = out;
                }

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

                Ok(())
            }
        }

        pub struct Import<T0, T1> {
            id: T0,

            capability: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Import<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireCapability<'static>>,
        {
            type Encoded = crate::WireCapabilityStoreImportRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = crate::WireCapability<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        id,
                        capability,

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct ConnectorCreate<T0, T1> {
            id: T0,

            receiver: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for ConnectorCreate<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ClientEnd<
                    crate::Receiver,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreConnectorCreateRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct ConnectorOpen<T0, T1> {
            id: T0,

            server_end: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for ConnectorOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireCapabilityStoreConnectorOpenRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DirConnectorCreate<T0, T1> {
            id: T0,

            receiver: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DirConnectorCreate<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ClientEnd<
                    crate::DirReceiver,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DirConnectorOpen<T0, T1> {
            id: T0,

            server_end: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DirConnectorOpen<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryCreate<T0> {
            id: T0,
        }

        impl<T0> ::fidl_next::Encodable for DictionaryCreate<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryCreateRequest;
        }

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

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

                    } = out;
                }

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

                Ok(())
            }
        }

        pub struct DictionaryLegacyImport<T0, T1> {
            id: T0,

            client_end: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyImport<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryLegacyExport<T0, T1> {
            id: T0,

            server_end: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyExport<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryInsert<T0, T1> {
            id: T0,

            item: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryInsert<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = crate::WireDictionaryItem<'static>>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryGet<T0, T1, T2> {
            id: T0,

            key: T1,

            dest_id: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryGet<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

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

                    } = out;
                }

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

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

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

                Ok(())
            }
        }

        pub struct DictionaryRemove<T0, T1, T2> {
            id: T0,

            key: T1,

            dest_id: T2,
        }

        impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryRemove<T0, T1, T2>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,

            T2: ::fidl_next::Encodable<
                Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,

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

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

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

                Ok(())
            }
        }

        pub struct DictionaryCopy<T0, T1> {
            id: T0,

            dest_id: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryCopy<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryCopyRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryKeys<T0, T1> {
            id: T0,

            iterator: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryKeys<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::DictionaryKeysIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryKeysRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryEnumerate<T0, T1> {
            id: T0,

            iterator: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerate<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::DictionaryEnumerateIterator,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        pub struct DictionaryDrain<T0, T1> {
            id: T0,

            iterator: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for DictionaryDrain<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::DictionaryDrainIterator,
                    ::fidl_next::fuchsia::WireOptionalChannel,
                >,
            >,
        {
            type Encoded = crate::WireCapabilityStoreDictionaryDrainRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

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

                    } = out;
                }

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

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::CapabilityStore
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = CapabilityStoreClientSender<___T>;
            type ServerSender = CapabilityStoreServerSender<___T>;
        }

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

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

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                dest_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Duplicate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.duplicate_with(Duplicate { id, dest_id })
            }

            #[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"]
            pub fn duplicate_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Duplicate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDuplicateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn drop(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Drop, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.drop_with(Drop { id })
            }

            #[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"]
            pub fn drop_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Drop, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDropRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn export(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Export, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.export_with(Export { id })
            }

            #[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"]
            pub fn export_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Export, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreExportRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn import(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

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

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.import_with(Import { id, capability })
            }

            #[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"]
            pub fn import_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::Import, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreImportRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn connector_create(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                receiver: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ClientEnd<
                        crate::Receiver,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ConnectorCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.connector_create_with(ConnectorCreate { id, receiver })
            }

            #[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"]
            pub fn connector_create_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ConnectorCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreConnectorCreateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn connector_open(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                server_end: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ConnectorOpen, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.connector_open_with(ConnectorOpen { id, server_end })
            }

            #[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"]
            pub fn connector_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::ConnectorOpen, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreConnectorOpenRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dir_connector_create(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                receiver: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ClientEnd<
                        crate::DirReceiver,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DirConnectorCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dir_connector_create_with(DirConnectorCreate { id, receiver })
            }

            #[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"]
            pub fn dir_connector_create_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DirConnectorCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dir_connector_open(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                server_end: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DirConnectorOpen, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dir_connector_open_with(DirConnectorOpen { id, server_end })
            }

            #[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"]
            pub fn dir_connector_open_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DirConnectorOpen, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_create(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.dictionary_create_with(DictionaryCreate { id })
            }

            #[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"]
            pub fn dictionary_create_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryCreate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryCreateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_legacy_import(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                client_end: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryLegacyImport, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dictionary_legacy_import_with(DictionaryLegacyImport { id, client_end })
            }

            #[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"]
            pub fn dictionary_legacy_import_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryLegacyImport, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_legacy_export(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                server_end: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryLegacyExport, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dictionary_legacy_export_with(DictionaryLegacyExport { id, server_end })
            }

            #[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"]
            pub fn dictionary_legacy_export_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryLegacyExport, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_insert(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

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

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.dictionary_insert_with(DictionaryInsert { id, item })
            }

            #[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"]
            pub fn dictionary_insert_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryInsert, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_get(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                key: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                dest_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryGet, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.dictionary_get_with(DictionaryGet { id, key, dest_id })
            }

            #[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"]
            pub fn dictionary_get_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryGet, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_remove(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                key: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                dest_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryRemove, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.dictionary_remove_with(DictionaryRemove { id, key, dest_id })
            }

            #[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"]
            pub fn dictionary_remove_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryRemove, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_copy(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                dest_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryCopy, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.dictionary_copy_with(DictionaryCopy { id, dest_id })
            }

            #[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"]
            pub fn dictionary_copy_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryCopy, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryCopyRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_keys(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::DictionaryKeysIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryKeys, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dictionary_keys_with(DictionaryKeys { id, iterator })
            }

            #[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"]
            pub fn dictionary_keys_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryKeys, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryKeysRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_enumerate(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::DictionaryEnumerateIterator,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryEnumerate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dictionary_enumerate_with(DictionaryEnumerate { id, iterator })
            }

            #[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"]
            pub fn dictionary_enumerate_with<___R>(
                &self,
                request: ___R,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryEnumerate, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest,
                >,
            {
                self.sender
                    .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"]
            pub fn dictionary_drain(
                &self,

                id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                iterator: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::DictionaryDrainIterator,
                        ::fidl_next::fuchsia::WireOptionalChannel,
                    >,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::DictionaryDrain, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.dictionary_drain_with(DictionaryDrain { id, iterator })
            }

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

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

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

/// 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<CapabilityStore, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

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

    <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>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    #[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<CapabilityStore, ___T>,

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

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<CapabilityStore, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.duplicate(sender, decoded, responder).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await
                    }
                    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).await
                    }
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    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).await,
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::Wire for WireInstanceToken {
    type Decoded<'de> = 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.metadata.is_some() {
            return 2;
        }

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

        0
    }
}

impl ::fidl_next::Encodable for RouteRequest {
    type Encoded = WireRouteRequest<'static>;
}

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::Wire::zero_padding(&mut out);

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireRouteRequest<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

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

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::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<'de> WireRouteRequest<'de> {
    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<'de> ::core::fmt::Debug for WireRouteRequest<'de> {
    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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConnectorRouterRouteResponse { raw, _phantom: _ } = 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 ConnectorRouterRouteResponse {
    type EncodedOption = WireOptionalConnectorRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireConnectorRouterRouteResponse> for ConnectorRouterRouteResponse {
    #[inline]
    fn from_wire(wire: WireConnectorRouterRouteResponse) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConnector>()
            })),

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

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

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

/// The wire type corresponding to [`ConnectorRouterRouteResponse`].
#[repr(transparent)]
pub struct WireConnectorRouterRouteResponse {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

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

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

pub mod connector_router_route_response {
    pub enum Ref<'de> {
        Connector(&'de crate::WireConnector),

        Unavailable(&'de 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, _phantom: _ } = 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,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

impl 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
        }
    }

    pub fn into_option(self) -> Option<WireConnectorRouterRouteResponse> {
        if self.is_some() {
            Some(WireConnectorRouterRouteResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } 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, _phantom: _ } = 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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RouterError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::FromWire<WireRouterError> for RouterError {
    #[inline]
    fn from_wire(wire: WireRouterError) -> Self {
        Self::from(wire)
    }
}

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

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

    #[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 = "fuchsia.component.sandbox.ConnectorRouter";
}

pub mod connector_router {
    pub mod prelude {
        pub use crate::{
            connector_router, ConnectorRouter, ConnectorRouterClientHandler,
            ConnectorRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireConnectorRouterRouteResponse,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ConnectorRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ConnectorRouterClientSender<___T>;
            type ServerSender = ConnectorRouterServerSender<___T>;
        }

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

        impl<___T> ConnectorRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(8420527046218942310, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<ConnectorRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for ConnectorRouter
where
    ___H: ConnectorRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<connector_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<ConnectorRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for ConnectorRouter
where
    ___H: ConnectorRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Debug)]
pub enum DataRouterRouteResponse {
    Data(crate::Data),

    Unavailable(crate::Unit),
}

impl ::fidl_next::Encodable for DataRouterRouteResponse {
    type Encoded = WireDataRouterRouteResponse<'static>;
}

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

pub mod data_router_route_response {
    pub enum Ref<'de> {
        Data(&'de crate::WireData<'de>),

        Unavailable(&'de crate::WireUnit),
    }
}

impl<'de> WireDataRouterRouteResponse<'de> {
    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<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
                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<'de> ::core::fmt::Debug for WireDataRouterRouteResponse<'de> {
    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<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

impl<'de> WireOptionalDataRouterRouteResponse<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
                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<'de> ::core::fmt::Debug for WireOptionalDataRouterRouteResponse<'de> {
    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 = "fuchsia.component.sandbox.DataRouter";
}

pub mod data_router {
    pub mod prelude {
        pub use crate::{
            data_router, DataRouter, DataRouterClientHandler, DataRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDataRouterRouteResponse<'static>,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DataRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DataRouterClientSender<___T>;
            type ServerSender = DataRouterServerSender<___T>;
        }

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

        impl<___T> DataRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(3352890635970754564, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DataRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DataRouter
where
    ___H: DataRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<data_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DataRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DataRouter
where
    ___H: DataRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// The type corresponding to the Dictionary protocol.
#[derive(Debug)]
pub struct Dictionary;

impl ::fidl_next::Discoverable for Dictionary {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
}

pub mod dictionary {
    pub mod prelude {
        pub use crate::{dictionary, Dictionary, DictionaryClientHandler, DictionaryServerHandler};
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Dictionary
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DictionaryClientSender<___T>;
            type ServerSender = DictionaryServerSender<___T>;
        }

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

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

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

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

/// 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<Dictionary, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Dictionary
where
    ___H: DictionaryClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// 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<Dictionary, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Dictionary
where
    ___H: DictionaryServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

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

        Ok(())
    }
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextRequest>
    for DictionaryDrainIteratorGetNextRequest
{
    #[inline]
    fn from_wire(wire: WireDictionaryDrainIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::FromWire::from_wire(wire.start_id),

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

impl ::fidl_next::FromWireRef<WireDictionaryDrainIteratorGetNextRequest>
    for DictionaryDrainIteratorGetNextRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireDictionaryDrainIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),

            limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireDictionaryDrainIteratorGetNextRequest {
    type Decoded<'de> = 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<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextResponse<'de>>
    for DictionaryDrainIteratorGetNextResponse
{
    #[inline]
    fn from_wire(wire: WireDictionaryDrainIteratorGetNextResponse<'de>) -> Self {
        Self {
            items: ::fidl_next::FromWire::from_wire(wire.items),

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

/// The wire type corresponding to [`DictionaryDrainIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryDrainIteratorGetNextResponse<'de> {
    pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryItem<'de>>,

    pub end_id: ::fidl_next::WireU64,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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, DictionaryDrainIteratorServerHandler,
        };

        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<
            'static,
            crate::WireDictionaryDrainIteratorGetNextResponse<'static>,
            crate::WireCapabilityStoreError,
        >;
    }

    mod ___detail {

        pub struct GetNext<T0, T1> {
            start_id: T0,

            limit: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
        {
            type Encoded = crate::WireDictionaryDrainIteratorGetNextRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
        {
            #[inline]
            fn encode(
                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(self.start_id, encoder, start_id)?;

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryDrainIterator
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DictionaryDrainIteratorClientSender<___T>;
            type ServerSender = DictionaryDrainIteratorServerSender<___T>;
        }

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

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

                start_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                limit: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU32,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetNext, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_next_with(GetNext { start_id, limit })
            }

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

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

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

/// 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<DictionaryDrainIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DictionaryDrainIterator
where
    ___H: DictionaryDrainIteratorClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DictionaryDrainIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DictionaryDrainIterator
where
    ___H: DictionaryDrainIteratorServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

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

        Ok(())
    }
}

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextRequest>
    for DictionaryEnumerateIteratorGetNextRequest
{
    #[inline]
    fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::FromWire::from_wire(wire.start_id),

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

impl ::fidl_next::FromWireRef<WireDictionaryEnumerateIteratorGetNextRequest>
    for DictionaryEnumerateIteratorGetNextRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
        Self {
            start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),

            limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.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::Wire for WireDictionaryEnumerateIteratorGetNextRequest {
    type Decoded<'de> = 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<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDictionaryOptionalItem<'de>> for DictionaryOptionalItem {
    #[inline]
    fn from_wire(wire: WireDictionaryOptionalItem<'de>) -> Self {
        Self {
            key: ::fidl_next::FromWire::from_wire(wire.key),

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

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

    pub value: ::fidl_next::WireBox<'de, crate::WireWrappedCapabilityId>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextResponse<'de>>
    for DictionaryEnumerateIteratorGetNextResponse
{
    #[inline]
    fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
        Self {
            items: ::fidl_next::FromWire::from_wire(wire.items),

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

/// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryEnumerateIteratorGetNextResponse<'de> {
    pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryOptionalItem<'de>>,

    pub end_id: ::fidl_next::WireU64,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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, DictionaryEnumerateIteratorServerHandler,
        };

        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<
            'static,
            crate::WireDictionaryEnumerateIteratorGetNextResponse<'static>,
            crate::WireCapabilityStoreError,
        >;
    }

    mod ___detail {

        pub struct GetNext<T0, T1> {
            start_id: T0,

            limit: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
        {
            type Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest;
        }

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

            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,

            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
        {
            #[inline]
            fn encode(
                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(self.start_id, encoder, start_id)?;

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryEnumerateIterator
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DictionaryEnumerateIteratorClientSender<___T>;
            type ServerSender = DictionaryEnumerateIteratorServerSender<___T>;
        }

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

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

                start_id: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU64,
                >,

                limit: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU32,
                >,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetNext, ___T>,
                ::fidl_next::EncodeError,
            >
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.get_next_with(GetNext { start_id, limit })
            }

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

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

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

/// 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<DictionaryEnumerateIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DictionaryEnumerateIterator
where
    ___H: DictionaryEnumerateIteratorClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DictionaryEnumerateIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DictionaryEnumerateIterator
where
    ___H: DictionaryEnumerateIteratorServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::FromWire<WireDictionaryError> for DictionaryError {
    #[inline]
    fn from_wire(wire: WireDictionaryError) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDictionaryKeysIteratorGetNextResponse<'de>>
    for DictionaryKeysIteratorGetNextResponse
{
    #[inline]
    fn from_wire(wire: WireDictionaryKeysIteratorGetNextResponse<'de>) -> Self {
        Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
    }
}

/// The wire type corresponding to [`DictionaryKeysIteratorGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDictionaryKeysIteratorGetNextResponse<'de> {
    pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut 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,
            DictionaryKeysIteratorServerHandler,
        };

        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<
            'static,
            crate::WireDictionaryKeysIteratorGetNextResponse<'static>,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryKeysIterator
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DictionaryKeysIteratorClientSender<___T>;
            type ServerSender = DictionaryKeysIteratorServerSender<___T>;
        }

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

        impl<___T> DictionaryKeysIteratorClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn get_next(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetNext, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(4987781442555247955, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DictionaryKeysIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DictionaryKeysIterator
where
    ___H: DictionaryKeysIteratorClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DictionaryKeysIterator, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DictionaryKeysIterator
where
    ___H: DictionaryKeysIteratorServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

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

                handler.get_next(sender, responder).await;
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDictionaryRouterRouteResponse { raw, _phantom: _ } = 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 DictionaryRouterRouteResponse {
    type EncodedOption = WireOptionalDictionaryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDictionaryRouterRouteResponse> for DictionaryRouterRouteResponse {
    #[inline]
    fn from_wire(wire: WireDictionaryRouterRouteResponse) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
            })),

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

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

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

/// The wire type corresponding to [`DictionaryRouterRouteResponse`].
#[repr(transparent)]
pub struct WireDictionaryRouterRouteResponse {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

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

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

pub mod dictionary_router_route_response {
    pub enum Ref<'de> {
        Dictionary(&'de crate::WireDictionaryRef),

        Unavailable(&'de 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, _phantom: _ } = 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,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

impl 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
        }
    }

    pub fn into_option(self) -> Option<WireDictionaryRouterRouteResponse> {
        if self.is_some() {
            Some(WireDictionaryRouterRouteResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } 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, _phantom: _ } = 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 = "fuchsia.component.sandbox.DictionaryRouter";
}

pub mod dictionary_router {
    pub mod prelude {
        pub use crate::{
            dictionary_router, DictionaryRouter, DictionaryRouterClientHandler,
            DictionaryRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDictionaryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DictionaryRouterClientSender<___T>;
            type ServerSender = DictionaryRouterServerSender<___T>;
        }

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

        impl<___T> DictionaryRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(8164012099375978399, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DictionaryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DictionaryRouter
where
    ___H: DictionaryRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<dictionary_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DictionaryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DictionaryRouter
where
    ___H: DictionaryRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDirConnectorRouterRouteResponse { raw, _phantom: _ } = 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 DirConnectorRouterRouteResponse {
    type EncodedOption = WireOptionalDirConnectorRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDirConnectorRouterRouteResponse>
    for DirConnectorRouterRouteResponse
{
    #[inline]
    fn from_wire(wire: WireDirConnectorRouterRouteResponse) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirConnector>()
            })),

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

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

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

/// The wire type corresponding to [`DirConnectorRouterRouteResponse`].
#[repr(transparent)]
pub struct WireDirConnectorRouterRouteResponse {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

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

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

pub mod dir_connector_router_route_response {
    pub enum Ref<'de> {
        DirConnector(&'de crate::WireDirConnector),

        Unavailable(&'de 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, _phantom: _ } = 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,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

impl 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
        }
    }

    pub fn into_option(self) -> Option<WireDirConnectorRouterRouteResponse> {
        if self.is_some() {
            Some(WireDirConnectorRouterRouteResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } 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, _phantom: _ } = 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 = "fuchsia.component.sandbox.DirConnectorRouter";
}

pub mod dir_connector_router {
    pub mod prelude {
        pub use crate::{
            dir_connector_router, DirConnectorRouter, DirConnectorRouterClientHandler,
            DirConnectorRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDirConnectorRouterRouteResponse,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirConnectorRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirConnectorRouterClientSender<___T>;
            type ServerSender = DirConnectorRouterServerSender<___T>;
        }

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

        impl<___T> DirConnectorRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(972231070188342848, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DirConnectorRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DirConnectorRouter
where
    ___H: DirConnectorRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<dir_connector_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DirConnectorRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DirConnectorRouter
where
    ___H: DirConnectorRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDirEntryRouterRouteResponse { raw, _phantom: _ } = 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 DirEntryRouterRouteResponse {
    type EncodedOption = WireOptionalDirEntryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDirEntryRouterRouteResponse> for DirEntryRouterRouteResponse {
    #[inline]
    fn from_wire(wire: WireDirEntryRouterRouteResponse) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDirEntry>()
            })),

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

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

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

/// The wire type corresponding to [`DirEntryRouterRouteResponse`].
#[repr(transparent)]
pub struct WireDirEntryRouterRouteResponse {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

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

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

pub mod dir_entry_router_route_response {
    pub enum Ref<'de> {
        DirEntry(&'de crate::WireDirEntry),

        Unavailable(&'de 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, _phantom: _ } = 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,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

impl 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
        }
    }

    pub fn into_option(self) -> Option<WireDirEntryRouterRouteResponse> {
        if self.is_some() {
            Some(WireDirEntryRouterRouteResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } 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, _phantom: _ } = 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 = "fuchsia.component.sandbox.DirEntryRouter";
}

pub mod dir_entry_router {
    pub mod prelude {
        pub use crate::{
            dir_entry_router, DirEntryRouter, DirEntryRouterClientHandler,
            DirEntryRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDirEntryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirEntryRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirEntryRouterClientSender<___T>;
            type ServerSender = DirEntryRouterServerSender<___T>;
        }

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

        impl<___T> DirEntryRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(1929392218567642066, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DirEntryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DirEntryRouter
where
    ___H: DirEntryRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<dir_entry_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DirEntryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DirEntryRouter
where
    ___H: DirEntryRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct DirReceiverReceiveRequest {
    pub channel: ::fidl_next::ServerEnd<
        ::fidl_next_fuchsia_io::Directory,
        ::fidl_next::fuchsia::zx::Channel,
    >,
}

impl ::fidl_next::Encodable for DirReceiverReceiveRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirReceiverReceiveRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                ::fidl_next_fuchsia_io::Directory,
                ::fidl_next::fuchsia::zx::Channel,
            > 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(
        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(self.channel, encoder, channel)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDirReceiverReceiveRequest> for DirReceiverReceiveRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirReceiverReceiveRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::ServerEnd<
                ::fidl_next_fuchsia_io::Directory,
                ::fidl_next::fuchsia::zx::Channel,
            > as ::fidl_next::FromWire<
                ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`DirReceiverReceiveRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDirReceiverReceiveRequest {
    pub channel: ::fidl_next::ServerEnd<
        ::fidl_next_fuchsia_io::Directory,
        ::fidl_next::fuchsia::WireChannel,
    >,
}

unsafe impl ::fidl_next::Wire for WireDirReceiverReceiveRequest {
    type Decoded<'de> = 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 = "fuchsia.component.sandbox.DirReceiver";
}

pub mod dir_receiver {
    pub mod prelude {
        pub use crate::{
            dir_receiver, DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler,
        };

        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;
    }

    mod ___detail {

        pub struct Receive<T0> {
            channel: T0,
        }

        impl<T0> ::fidl_next::Encodable for Receive<T0>
        where
            T0: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireDirReceiverReceiveRequest;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        channel,

                    } = out;
                }

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirReceiver
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirReceiverClientSender<___T>;
            type ServerSender = DirReceiverServerSender<___T>;
        }

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

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

                channel: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        ::fidl_next_fuchsia_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.receive_with(Receive { channel })
            }

            #[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"]
            pub fn receive_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireDirReceiverReceiveRequest,
                >,
            {
                self.sender.send_one_way(926684461087488948, request)
            }
        }

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

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

/// 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<DirReceiver, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DirReceiver
where
    ___H: DirReceiverClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

        request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DirReceiver, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DirReceiver
where
    ___H: DirReceiverServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <dir_receiver::Receive as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.receive(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Debug)]
pub enum DirectoryRouterRouteResponse {
    Directory(
        ::fidl_next::ClientEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    ),

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

        match self {
            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                ::fidl_next::ClientEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::zx::Channel,
                >,
            >(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 DirectoryRouterRouteResponse {
    type EncodedOption = WireOptionalDirectoryRouterRouteResponse;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireDirectoryRouterRouteResponse> for DirectoryRouterRouteResponse {
    #[inline]
    fn from_wire(wire: WireDirectoryRouterRouteResponse) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                    ::fidl_next_fuchsia_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            })),

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

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

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

/// The wire type corresponding to [`DirectoryRouterRouteResponse`].
#[repr(transparent)]
pub struct WireDirectoryRouterRouteResponse {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

impl Drop for WireDirectoryRouterRouteResponse {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next_fuchsia_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                };
            }

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

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

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

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

pub mod directory_router_route_response {
    pub enum Ref<'de> {
        Directory(
            &'de ::fidl_next::ClientEnd<
                ::fidl_next_fuchsia_io::Directory,
                ::fidl_next::fuchsia::WireChannel,
            >,
        ),

        Unavailable(&'de 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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >>()
            }),

            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, _phantom: _ } = 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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >(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_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                    .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,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

impl 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
        }
    }

    pub fn into_option(self) -> Option<WireDirectoryRouterRouteResponse> {
        if self.is_some() {
            Some(WireDirectoryRouterRouteResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
        } 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, _phantom: _ } = 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_io::Directory,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >(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 = "fuchsia.component.sandbox.DirectoryRouter";
}

pub mod directory_router {
    pub mod prelude {
        pub use crate::{
            directory_router, DirectoryRouter, DirectoryRouterClientHandler,
            DirectoryRouterServerHandler,
        };

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDirectoryRouterRouteResponse,
            crate::WireRouterError,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirectoryRouter
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = DirectoryRouterClientSender<___T>;
            type ServerSender = DirectoryRouterServerSender<___T>;
        }

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

        impl<___T> DirectoryRouterClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn route_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::ResponseFuture<'_, super::Route, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireRouteRequest<'static>,
                >,
            {
                self.sender
                    .send_two_way(7510716014181158689, request)
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

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

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

/// 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<DirectoryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for DirectoryRouter
where
    ___H: DirectoryRouterClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

        request: ::fidl_next::Request<directory_router::Route, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<DirectoryRouter, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for DirectoryRouter
where
    ___H: DirectoryRouterServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

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

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

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

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::Wire for WireProtocolPayload {
    type Decoded<'de> = 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 = "fuchsia.component.sandbox.Receiver";
}

pub mod receiver {
    pub mod prelude {
        pub use crate::{receiver, Receiver, ReceiverClientHandler, ReceiverServerHandler};

        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;
    }

    mod ___detail {

        pub struct Receive<T0> {
            channel: T0,
        }

        impl<T0> ::fidl_next::Encodable for Receive<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireHandle>,
        {
            type Encoded = crate::WireProtocolPayload;
        }

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

            ___E: ::fidl_next::fuchsia::HandleEncoder,

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

                    } = out;
                }

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Receiver
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ReceiverClientSender<___T>;
            type ServerSender = ReceiverServerSender<___T>;
        }

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

        impl<___T> ReceiverClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Sends a channel to this receiver.\n"]
            pub fn receive(
                &self,

                channel: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::fuchsia::WireHandle,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.receive_with(Receive { channel })
            }

            #[doc = " Sends a channel to this receiver.\n"]
            pub fn receive_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireProtocolPayload,
                >,
            {
                self.sender.send_one_way(340832707723008660, request)
            }
        }

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

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

/// 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<Receiver, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for Receiver
where
    ___H: ReceiverClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

        request: ::fidl_next::Request<receiver::Receive, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<Receiver, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for Receiver
where
    ___H: ReceiverServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <receiver::Receive as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.receive(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

impl ::fidl_next::Encodable for Unavailable {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireUnavailable> =
        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(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

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

            } = out;
        }

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireUnavailable> for Unavailable {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireUnavailable, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

unsafe impl ::fidl_next::Wire for WireUnavailable {
    type Decoded<'de> = 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 ::core::convert::From<crate::Availability> for ::fidl_fuchsia_component_sandbox::Availability {
        #[inline]
        fn from(from: crate::Availability) -> 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 ::core::convert::From<crate::CapabilityStoreError>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
    {
        #[inline]
        fn from(from: crate::CapabilityStoreError) -> 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 }
                }
            }
        }
    }

    #[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 ::core::convert::From<crate::CapabilityStore>
        for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
    {
        #[inline]
        fn from(_: crate::CapabilityStore) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
        #[inline]
        fn from(from: crate::RouterError) -> 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 ::core::convert::From<crate::ConnectorRouter>
        for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
    {
        #[inline]
        fn from(_: crate::ConnectorRouter) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DataRouter>
        for ::fidl_fuchsia_component_sandbox::DataRouterMarker
    {
        #[inline]
        fn 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 ::core::convert::From<crate::Dictionary>
        for ::fidl_fuchsia_component_sandbox::DictionaryMarker
    {
        #[inline]
        fn from(_: crate::Dictionary) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DictionaryDrainIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
    {
        #[inline]
        fn from(_: crate::DictionaryDrainIterator) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DictionaryEnumerateIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
    {
        #[inline]
        fn from(_: crate::DictionaryEnumerateIterator) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::DictionaryError>
        for ::fidl_fuchsia_component_sandbox::DictionaryError
    {
        #[inline]
        fn from(from: crate::DictionaryError) -> 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 }
                }
            }
        }
    }

    #[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 ::core::convert::From<crate::DictionaryKeysIterator>
        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
    {
        #[inline]
        fn from(_: crate::DictionaryKeysIterator) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DictionaryRouter>
        for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
    {
        #[inline]
        fn from(_: crate::DictionaryRouter) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DirConnectorRouter>
        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
    {
        #[inline]
        fn from(_: crate::DirConnectorRouter) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DirEntryRouter>
        for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
    {
        #[inline]
        fn from(_: crate::DirEntryRouter) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DirReceiver>
        for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
    {
        #[inline]
        fn from(_: crate::DirReceiver) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::DirectoryRouter>
        for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
    {
        #[inline]
        fn from(_: crate::DirectoryRouter) -> Self {
            Self
        }
    }

    #[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 ::core::convert::From<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
        #[inline]
        fn from(_: crate::Receiver) -> Self {
            Self
        }
    }
}