fidl_next_fuchsia_component_decl/

fidl_next_fuchsia_component_decl.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 = " The kinds of offers that can target the children in a collection.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum AllowedOffers {
    StaticOnly = 1,
    StaticAndDynamic = 2,
}

impl ::fidl_next::Encodable for AllowedOffers {
    type Encoded = WireAllowedOffers;
}
impl ::std::convert::TryFrom<u32> for AllowedOffers {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::StaticOnly),
            2 => Ok(Self::StaticAndDynamic),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for AllowedOffers
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 AllowedOffers
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 WireAllowedOffers { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::StaticOnly => 1,

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

        Ok(())
    }
}

impl ::core::convert::From<WireAllowedOffers> for AllowedOffers {
    fn from(wire: WireAllowedOffers) -> Self {
        match u32::from(wire.value) {
            1 => Self::StaticOnly,

            2 => Self::StaticAndDynamic,

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

impl ::fidl_next::FromWire<WireAllowedOffers> for AllowedOffers {
    #[inline]
    fn from_wire(wire: WireAllowedOffers) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireAllowedOffers {
    pub const STATIC_ONLY: WireAllowedOffers = WireAllowedOffers { value: ::fidl_next::WireU32(1) };

    pub const STATIC_AND_DYNAMIC: WireAllowedOffers =
        WireAllowedOffers { value: ::fidl_next::WireU32(2) };
}

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

        Ok(())
    }
}

impl ::core::convert::From<AllowedOffers> for WireAllowedOffers {
    fn from(natural: AllowedOffers) -> Self {
        match natural {
            AllowedOffers::StaticOnly => WireAllowedOffers::STATIC_ONLY,

            AllowedOffers::StaticAndDynamic => WireAllowedOffers::STATIC_AND_DYNAMIC,
        }
    }
}

#[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,
        }
    }
}

#[doc = " Config keys can only consist of these many bytes\n"]
pub const CONFIG_KEY_MAX_SIZE: u32 = 64;

pub const MAX_NAME_LENGTH: u32 = 100;

pub type Name = String;

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

pub const MAX_PATH_LENGTH: u32 = 1024;

#[doc = " Declares a service capability backed by this component.\n\n To learn more about services, see:\n https://fuchsia.dev/fuchsia-src/glossary#service\n"]
#[derive(Clone, Debug, Default)]
pub struct Service {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Service {
    type Encoded = WireService<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Service
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireService { 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(source_path) = self.source_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Service
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireService { 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(source_path) = &self.source_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireService<'de>> for Service {
    #[inline]
    fn from_wire(wire: WireService<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireService<'static> {
    type Decoded<'de> = WireService<'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 WireService<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

impl<'de> WireService<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[doc = " Declares a directory capability backed by this component.\n\n To learn more about directories, see:\n https://fuchsia.dev/fuchsia-src/glossary#directory\n"]
#[derive(Clone, Debug, Default)]
pub struct Directory {
    pub name: Option<String>,

    pub source_path: Option<String>,

    pub rights: Option<::fidl_next_fuchsia_io::Operations>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Directory {
    type Encoded = WireDirectory<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireDirectory<'de>> for Directory {
    #[inline]
    fn from_wire(wire: WireDirectory<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireDirectory<'static> {
    type Decoded<'de> = WireDirectory<'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 WireDirectory<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireDirectory<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn rights(&self) -> Option<&::fidl_next_fuchsia_io::WireOperations> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

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

#[doc = " A reference to a component\'s parent instance.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct ParentRef {}

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

    type Encoded = WireParentRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ParentRef
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 ParentRef
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 ParentRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireParentRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ParentRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ParentRef: ::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 ParentRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ParentRef: ::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<WireParentRef> for ParentRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireParentRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireParentRef
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 = " A reference to the component itself.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct SelfRef {}

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

    type Encoded = WireSelfRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for SelfRef
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 SelfRef
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 SelfRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireSelfRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for SelfRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SelfRef: ::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 SelfRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    SelfRef: ::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<WireSelfRef> for SelfRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireSelfRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

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

pub const MAX_CHILD_NAME_LENGTH: u32 = 1024;

pub type ChildName = String;

/// The wire type corresponding to [`ChildName`].
pub type WireChildName<'de> = ::fidl_next::WireString<'de>;

#[doc = " A reference to one of the component\'s child instances.\n"]
#[derive(Clone, Debug)]
pub struct ChildRef {
    pub name: String,

    pub collection: Option<String>,
}

impl ::fidl_next::Encodable for ChildRef {
    type Encoded = WireChildRef<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

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

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

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

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

    pub collection: ::fidl_next::WireOptionalString<'de>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

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

        if let Some(collection) = collection.as_ref() {
            if collection.len() > 100 {
                return Err(::fidl_next::DecodeError::VectorTooLong {
                    size: collection.len() as u64,
                    limit: 100,
                });
            }
        }

        Ok(())
    }
}

#[doc = " A reference to one of the component\'s collections.\n"]
#[derive(Clone, Debug)]
pub struct CollectionRef {
    pub name: String,
}

impl ::fidl_next::Encodable for CollectionRef {
    type Encoded = WireCollectionRef<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

            } = slot;
        }

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

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

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

        Ok(())
    }
}

#[doc = " A reference to the component framework itself.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct FrameworkRef {}

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

    type Encoded = WireFrameworkRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for FrameworkRef
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 FrameworkRef
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 FrameworkRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireFrameworkRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for FrameworkRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FrameworkRef: ::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 FrameworkRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    FrameworkRef: ::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<WireFrameworkRef> for FrameworkRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireFrameworkRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireFrameworkRef
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 = " A reference to a capability declared in this component.\n"]
#[derive(Clone, Debug)]
pub struct CapabilityRef {
    pub name: String,
}

impl ::fidl_next::Encodable for CapabilityRef {
    type Encoded = WireCapabilityRef<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

            } = slot;
        }

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

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

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

        Ok(())
    }
}

#[doc = " A reference to the environment\'s debug capabilities.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct DebugRef {}

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

    type Encoded = WireDebugRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DebugRef
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 DebugRef
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 DebugRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDebugRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DebugRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DebugRef: ::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 DebugRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DebugRef: ::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<WireDebugRef> for DebugRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDebugRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDebugRef
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 = " A reference to an intentionally missing offer source.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct VoidRef {}

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

    type Encoded = WireVoidRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for VoidRef
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 VoidRef
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 VoidRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireVoidRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for VoidRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    VoidRef: ::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 VoidRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    VoidRef: ::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<WireVoidRef> for VoidRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireVoidRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireVoidRef
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 = " Declares which identifier to use to key a component\'s isolated storage\n directory.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum StorageId {
    StaticInstanceId = 1,
    StaticInstanceIdOrMoniker = 2,
}

impl ::fidl_next::Encodable for StorageId {
    type Encoded = WireStorageId;
}
impl ::std::convert::TryFrom<u32> for StorageId {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::StaticInstanceId),
            2 => Ok(Self::StaticInstanceIdOrMoniker),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for StorageId
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 StorageId
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 WireStorageId { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::StaticInstanceId => 1,

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

        Ok(())
    }
}

impl ::core::convert::From<WireStorageId> for StorageId {
    fn from(wire: WireStorageId) -> Self {
        match u32::from(wire.value) {
            1 => Self::StaticInstanceId,

            2 => Self::StaticInstanceIdOrMoniker,

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

impl ::fidl_next::FromWire<WireStorageId> for StorageId {
    #[inline]
    fn from_wire(wire: WireStorageId) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireStorageId {
    pub const STATIC_INSTANCE_ID: WireStorageId = WireStorageId { value: ::fidl_next::WireU32(1) };

    pub const STATIC_INSTANCE_ID_OR_MONIKER: WireStorageId =
        WireStorageId { value: ::fidl_next::WireU32(2) };
}

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

        Ok(())
    }
}

impl ::core::convert::From<StorageId> for WireStorageId {
    fn from(natural: StorageId) -> Self {
        match natural {
            StorageId::StaticInstanceId => WireStorageId::STATIC_INSTANCE_ID,

            StorageId::StaticInstanceIdOrMoniker => WireStorageId::STATIC_INSTANCE_ID_OR_MONIKER,
        }
    }
}

#[doc = " Declares a runner capability backed by a service.\n"]
#[derive(Clone, Debug, Default)]
pub struct Runner {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Runner {
    type Encoded = WireRunner<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Runner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRunner { 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(source_path) = self.source_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Runner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRunner { 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(source_path) = &self.source_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireRunner<'de>> for Runner {
    #[inline]
    fn from_wire(wire: WireRunner<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireRunner<'static> {
    type Decoded<'de> = WireRunner<'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 WireRunner<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

impl<'de> WireRunner<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[doc = " Declares a resolver which is responsible for resolving component URLs to\n actual components. See `fuchsia.component.resolution.Resolver` for the\n protocol resolvers are expected to implement.\n"]
#[derive(Clone, Debug, Default)]
pub struct Resolver {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Resolver {
    type Encoded = WireResolver<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Resolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireResolver { 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(source_path) = self.source_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Resolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireResolver { 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(source_path) = &self.source_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireResolver<'de>> for Resolver {
    #[inline]
    fn from_wire(wire: WireResolver<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireResolver<'static> {
    type Decoded<'de> = WireResolver<'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 WireResolver<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

impl<'de> WireResolver<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[doc = " Declares an event_stream capability\n\n This type cannot be used in `fuchsia.component.decl.Component`. It is only\n used for the framework\'s built-in capabilities declared in\n `internal.Config`.\n"]
#[derive(Clone, Debug, Default)]
pub struct EventStream {
    pub name: Option<String>,
}

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

        0
    }
}

impl ::fidl_next::Encodable for EventStream {
    type Encoded = WireEventStream<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireEventStream<'de>> for EventStream {
    #[inline]
    fn from_wire(wire: WireEventStream<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireEventStream<'static> {
    type Decoded<'de> = WireEventStream<'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 WireEventStream<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

impl<'de> WireEventStream<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

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

#[doc = " A single configuration value.\n"]
#[derive(Clone, Debug)]
pub enum ConfigSingleValue {
    Bool(bool),

    Uint8(u8),

    Uint16(u16),

    Uint32(u32),

    Uint64(u64),

    Int8(i8),

    Int16(i16),

    Int32(i32),

    Int64(i64),

    String(String),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ConfigSingleValue {
    type Encoded = WireConfigSingleValue<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigSingleValue
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 WireConfigSingleValue { raw, _phantom: _ } = out);

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

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

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

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

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

            Self::Int8(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, i8>(value, 6, encoder, raw)?
            }

            Self::Int16(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, i16>(value, 7, encoder, raw)?
            }

            Self::Int32(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, i32>(value, 8, encoder, raw)?
            }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigSingleValue
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 WireConfigSingleValue { raw, _phantom: _ } = out);

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

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

            Self::Uint16(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &u16>(value, 3, encoder, raw)?
            }

            Self::Uint32(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &u32>(value, 4, encoder, raw)?
            }

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

            Self::Int8(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &i8>(value, 6, encoder, raw)?
            }

            Self::Int16(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &i16>(value, 7, encoder, raw)?
            }

            Self::Int32(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &i32>(value, 8, encoder, raw)?
            }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ConfigSingleValue {
    type EncodedOption = WireOptionalConfigSingleValue<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigSingleValue
where
    ___E: ?Sized,
    ConfigSingleValue: ::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 WireOptionalConfigSingleValue { 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 ConfigSingleValue
where
    ___E: ?Sized,
    ConfigSingleValue: ::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 WireOptionalConfigSingleValue { 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<WireConfigSingleValue<'de>> for ConfigSingleValue {
    #[inline]
    fn from_wire(wire: WireConfigSingleValue<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Bool(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<bool>()
            })),

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

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

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

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

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

            7 => Self::Int16(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireI16>()
            })),

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

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

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

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

impl<'de> ::fidl_next::FromWireRef<WireConfigSingleValue<'de>> for ConfigSingleValue {
    #[inline]
    fn from_wire_ref(wire: &WireConfigSingleValue<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Bool(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<bool>()
            })),

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

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

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

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

            6 => Self::Int8(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<i8>()
            })),

            7 => Self::Int16(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireI16>()
            })),

            8 => Self::Int32(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireI32>()
            })),

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

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

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalConfigSingleValue<'de>>
    for Box<ConfigSingleValue>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalConfigSingleValue<'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<WireOptionalConfigSingleValue<'de>>
    for Box<ConfigSingleValue>
{
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalConfigSingleValue<'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 [`ConfigSingleValue`].
#[repr(transparent)]
pub struct WireConfigSingleValue<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

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

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

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

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

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

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

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

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireConfigSingleValue<'static> {
    type Decoded<'de> = WireConfigSingleValue<'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 config_single_value {
    pub enum Ref<'de> {
        Bool(&'de bool),

        Uint8(&'de u8),

        Uint16(&'de ::fidl_next::WireU16),

        Uint32(&'de ::fidl_next::WireU32),

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

        Int8(&'de i8),

        Int16(&'de ::fidl_next::WireI16),

        Int32(&'de ::fidl_next::WireI32),

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

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireConfigSingleValue<'de> {
    pub fn as_ref(&self) -> crate::config_single_value::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::config_single_value::Ref::Bool(unsafe {
                self.raw.get().deref_unchecked::<bool>()
            }),

            2 => crate::config_single_value::Ref::Uint8(unsafe {
                self.raw.get().deref_unchecked::<u8>()
            }),

            3 => crate::config_single_value::Ref::Uint16(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU16>()
            }),

            4 => crate::config_single_value::Ref::Uint32(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            }),

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

            6 => crate::config_single_value::Ref::Int8(unsafe {
                self.raw.get().deref_unchecked::<i8>()
            }),

            7 => crate::config_single_value::Ref::Int16(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireI16>()
            }),

            8 => crate::config_single_value::Ref::Int32(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireI32>()
            }),

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

            10 => crate::config_single_value::Ref::String(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigSingleValue<'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, bool>(raw, decoder)?,

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

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

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

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

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, i8>(raw, decoder)?,

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI16>(raw, decoder)?,

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireConfigSingleValue<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<u8>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU16>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU32>().fmt(f) },
            5 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
            6 => unsafe { self.raw.get().deref_unchecked::<i8>().fmt(f) },
            7 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI16>().fmt(f) },
            8 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>().fmt(f) },
            9 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
            10 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalConfigSingleValue<'static> {
    type Decoded<'de> = WireOptionalConfigSingleValue<'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> WireOptionalConfigSingleValue<'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<&WireConfigSingleValue<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigSingleValue<'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, bool>(raw, decoder)?,

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

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

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

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

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, i8>(raw, decoder)?,

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI16>(raw, decoder)?,

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

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

#[doc = " A vector configuration value.\n"]
#[derive(Clone, Debug)]
pub enum ConfigVectorValue {
    BoolVector(Vec<bool>),

    Uint8Vector(Vec<u8>),

    Uint16Vector(Vec<u16>),

    Uint32Vector(Vec<u32>),

    Uint64Vector(Vec<u64>),

    Int8Vector(Vec<i8>),

    Int16Vector(Vec<i16>),

    Int32Vector(Vec<i32>),

    Int64Vector(Vec<i64>),

    StringVector(Vec<String>),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ConfigVectorValue {
    type Encoded = WireConfigVectorValue<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigVectorValue
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 WireConfigVectorValue { raw, _phantom: _ } = out);

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

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

            Self::Uint16Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<u16>>(value, 3, encoder, raw)?
            }

            Self::Uint32Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<u32>>(value, 4, encoder, raw)?
            }

            Self::Uint64Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<u64>>(value, 5, encoder, raw)?
            }

            Self::Int8Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<i8>>(value, 6, encoder, raw)?
            }

            Self::Int16Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<i16>>(value, 7, encoder, raw)?
            }

            Self::Int32Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<i32>>(value, 8, encoder, raw)?
            }

            Self::Int64Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<i64>>(value, 9, encoder, raw)?
            }

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigVectorValue
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 WireConfigVectorValue { raw, _phantom: _ } = out);

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

            Self::Uint8Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<u8>>(value, 2, encoder, raw)?
            }

            Self::Uint16Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<u16>>(value, 3, encoder, raw)?
            }

            Self::Uint32Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<u32>>(value, 4, encoder, raw)?
            }

            Self::Uint64Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<u64>>(value, 5, encoder, raw)?
            }

            Self::Int8Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<i8>>(value, 6, encoder, raw)?
            }

            Self::Int16Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<i16>>(value, 7, encoder, raw)?
            }

            Self::Int32Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<i32>>(value, 8, encoder, raw)?
            }

            Self::Int64Vector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<i64>>(value, 9, encoder, raw)?
            }

            Self::StringVector(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &Vec<String>>(value, 10, encoder, raw)?
            }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ConfigVectorValue {
    type EncodedOption = WireOptionalConfigVectorValue<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigVectorValue
where
    ___E: ?Sized,
    ConfigVectorValue: ::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 WireOptionalConfigVectorValue { 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 ConfigVectorValue
where
    ___E: ?Sized,
    ConfigVectorValue: ::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 WireOptionalConfigVectorValue { 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<WireConfigVectorValue<'de>> for ConfigVectorValue {
    #[inline]
    fn from_wire(wire: WireConfigVectorValue<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::BoolVector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, bool>>()
            })),

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

            3 => Self::Uint16Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU16>>()
            })),

            4 => Self::Uint32Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU32>>()
            })),

            5 => Self::Uint64Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU64>>()
            })),

            6 => Self::Int8Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, i8>>()
            })),

            7 => Self::Int16Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI16>>()
            })),

            8 => Self::Int32Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI32>>()
            })),

            9 => Self::Int64Vector(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI64>>()
            })),

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

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

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

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

            3 => Self::Uint16Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU16>>()
            })),

            4 => Self::Uint32Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU32>>()
            })),

            5 => Self::Uint64Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU64>>()
            })),

            6 => Self::Int8Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireVector<'de, i8>>()
            })),

            7 => Self::Int16Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI16>>()
            })),

            8 => Self::Int32Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI32>>()
            })),

            9 => Self::Int64Vector(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI64>>()
            })),

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

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalConfigVectorValue<'de>>
    for Box<ConfigVectorValue>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalConfigVectorValue<'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<WireOptionalConfigVectorValue<'de>>
    for Box<ConfigVectorValue>
{
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalConfigVectorValue<'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 [`ConfigVectorValue`].
#[repr(transparent)]
pub struct WireConfigVectorValue<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

            3 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU16>>()
                };
            }

            4 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU32>>()
                };
            }

            5 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireU64>>()
                };
            }

            6 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, i8>>() };
            }

            7 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI16>>()
                };
            }

            8 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI32>>()
                };
            }

            9 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireI64>>()
                };
            }

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireConfigVectorValue<'static> {
    type Decoded<'de> = WireConfigVectorValue<'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 config_vector_value {
    pub enum Ref<'de> {
        BoolVector(&'de ::fidl_next::WireVector<'de, bool>),

        Uint8Vector(&'de ::fidl_next::WireVector<'de, u8>),

        Uint16Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireU16>),

        Uint32Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireU32>),

        Uint64Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireU64>),

        Int8Vector(&'de ::fidl_next::WireVector<'de, i8>),

        Int16Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireI16>),

        Int32Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireI32>),

        Int64Vector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireI64>),

        StringVector(&'de ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireConfigVectorValue<'de> {
    pub fn as_ref(&self) -> crate::config_vector_value::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::config_vector_value::Ref::BoolVector(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, bool>>()
            }),

            2 => crate::config_vector_value::Ref::Uint8Vector(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
            }),

            3 => crate::config_vector_value::Ref::Uint16Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU16>>()
            }),

            4 => crate::config_vector_value::Ref::Uint32Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU32>>()
            }),

            5 => crate::config_vector_value::Ref::Uint64Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU64>>()
            }),

            6 => crate::config_vector_value::Ref::Int8Vector(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, i8>>()
            }),

            7 => crate::config_vector_value::Ref::Int16Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI16>>()
            }),

            8 => crate::config_vector_value::Ref::Int32Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI32>>()
            }),

            9 => crate::config_vector_value::Ref::Int64Vector(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI64>>()
            }),

            10 => {
                crate::config_vector_value::Ref::StringVector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireString<'_>>>()
                })
            }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigVectorValue<'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, bool>,
            >(raw, decoder)?,

            2 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
                    raw, decoder,
                )?
            }

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

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

            5 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireU64>,
            >(raw, decoder)?,

            6 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, i8>>(
                    raw, decoder,
                )?
            }

            7 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI16>,
            >(raw, decoder)?,

            8 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI32>,
            >(raw, decoder)?,

            9 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI64>,
            >(raw, decoder)?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
            >(raw, decoder)?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireConfigVectorValue<'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<'_, bool>>().fmt(f)
            },
            2 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
            },
            3 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU16>>()
                    .fmt(f)
            },
            4 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU32>>()
                    .fmt(f)
            },
            5 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireU64>>()
                    .fmt(f)
            },
            6 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, i8>>().fmt(f)
            },
            7 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI16>>()
                    .fmt(f)
            },
            8 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI32>>()
                    .fmt(f)
            },
            9 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireI64>>()
                    .fmt(f)
            },
            10 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireString<'_>>>()
                    .fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalConfigVectorValue<'static> {
    type Decoded<'de> = WireOptionalConfigVectorValue<'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> WireOptionalConfigVectorValue<'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<&WireConfigVectorValue<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigVectorValue<'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, bool>,
            >(raw, decoder)?,

            2 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
                    raw, decoder,
                )?
            }

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

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

            5 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireU64>,
            >(raw, decoder)?,

            6 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, i8>>(
                    raw, decoder,
                )?
            }

            7 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI16>,
            >(raw, decoder)?,

            8 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI32>,
            >(raw, decoder)?,

            9 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireI64>,
            >(raw, decoder)?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
            >(raw, decoder)?,

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

        Ok(())
    }
}

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

#[doc = " A configuration value which can be provided to a component.\n\n Used both for storing configuration at-rest and in runtime configuration APIs.\n"]
#[derive(Clone, Debug)]
pub enum ConfigValue {
    Single(crate::ConfigSingleValue),

    Vector(crate::ConfigVectorValue),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ConfigValue {
    type Encoded = WireConfigValue<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigValue
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 WireConfigValue { raw, _phantom: _ } = out);

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigValue
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 WireConfigValue { raw, _phantom: _ } = out);

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

            Self::Vector(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ConfigVectorValue,
            >(value, 2, encoder, raw)?,

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ConfigValue {
    type EncodedOption = WireOptionalConfigValue<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigValue
where
    ___E: ?Sized,
    ConfigValue: ::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 WireOptionalConfigValue { 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 ConfigValue
where
    ___E: ?Sized,
    ConfigValue: ::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 WireOptionalConfigValue { 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<WireConfigValue<'de>> for ConfigValue {
    #[inline]
    fn from_wire(wire: WireConfigValue<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Single(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConfigSingleValue<'de>>()
            })),

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

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

impl<'de> ::fidl_next::FromWireRef<WireConfigValue<'de>> for ConfigValue {
    #[inline]
    fn from_wire_ref(wire: &WireConfigValue<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Single(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireConfigSingleValue<'de>>()
            })),

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

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalConfigValue<'de>> for Box<ConfigValue> {
    #[inline]
    fn from_wire_option(wire: WireOptionalConfigValue<'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<WireOptionalConfigValue<'de>> for Box<ConfigValue> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalConfigValue<'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 [`ConfigValue`].
#[repr(transparent)]
pub struct WireConfigValue<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireConfigValue<'static> {
    type Decoded<'de> = WireConfigValue<'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 config_value {
    pub enum Ref<'de> {
        Single(&'de crate::WireConfigSingleValue<'de>),

        Vector(&'de crate::WireConfigVectorValue<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireConfigValue<'de> {
    pub fn as_ref(&self) -> crate::config_value::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::config_value::Ref::Single(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfigSingleValue<'_>>()
            }),

            2 => crate::config_value::Ref::Vector(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfigVectorValue<'_>>()
            }),

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigValue<'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, crate::WireConfigSingleValue<'static>>(
                    raw, decoder,
                )?
            }

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

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

        Ok(())
    }
}

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

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

unsafe impl ::fidl_next::Wire for WireOptionalConfigValue<'static> {
    type Decoded<'de> = WireOptionalConfigValue<'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> WireOptionalConfigValue<'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<&WireConfigValue<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigValue<'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, crate::WireConfigSingleValue<'static>>(
                    raw, decoder,
                )?
            }

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

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

        Ok(())
    }
}

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

#[doc = " Declares a configuration capability.\n\n To learn more about configuration capabilities, see:\n https://fuchsia.dev/fuchsia-src/glossary#configuration-capability\n or:\n https://fuchsia.dev/fuchsia-src/docs/concepts/components/v2/capabilities/configuration\n"]
#[derive(Clone, Debug, Default)]
pub struct Configuration {
    pub name: Option<String>,

    pub value: Option<crate::ConfigValue>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Configuration {
    type Encoded = WireConfiguration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Configuration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfiguration { 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(value) = self.value.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Configuration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfiguration { 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(value) = &self.value {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireConfiguration<'de>> for Configuration {
    #[inline]
    fn from_wire(wire: WireConfiguration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireConfiguration<'static> {
    type Decoded<'de> = WireConfiguration<'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 WireConfiguration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireConfiguration<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[doc = " Path in a dictionary. The format is similar to a directory path, except no `.` or `..`.\n is allowed and each path segment must conform to the format of the `name` type.\n\n The \"dirname\" (first to the penultimate segment, or empty if there is one\n segment) represents a sequence of nested dictionaries.\n The \"basename\" (last segment) identifies a capability in the last nested\n dictionary.\n"]
pub type DictionaryPath = String;

/// The wire type corresponding to [`DictionaryPath`].
pub type WireDictionaryPath<'de> = ::fidl_next::WireString<'de>;

#[doc = " `DeliveryType` may be used when declaring a capability, and specifies under\n what conditions the framework will open the capability from the provider\n component\'s outgoing directory when there is a request for this capability.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum DeliveryType {
    Immediate = 0,
    OnReadable = 1,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for DeliveryType {
    type Encoded = WireDeliveryType;
}
impl ::std::convert::From<u32> for DeliveryType {
    fn from(value: u32) -> Self {
        match value {
            0 => Self::Immediate,
            1 => Self::OnReadable,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for DeliveryType
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 DeliveryType
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 WireDeliveryType { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Immediate => 0,

            Self::OnReadable => 1,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDeliveryType> for DeliveryType {
    fn from(wire: WireDeliveryType) -> Self {
        match u32::from(wire.value) {
            0 => Self::Immediate,

            1 => Self::OnReadable,

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

impl ::fidl_next::FromWire<WireDeliveryType> for DeliveryType {
    #[inline]
    fn from_wire(wire: WireDeliveryType) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireDeliveryType {
    pub const IMMEDIATE: WireDeliveryType = WireDeliveryType { value: ::fidl_next::WireU32(0) };

    pub const ON_READABLE: WireDeliveryType = WireDeliveryType { value: ::fidl_next::WireU32(1) };
}

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

impl ::core::convert::From<DeliveryType> for WireDeliveryType {
    fn from(natural: DeliveryType) -> Self {
        match natural {
            DeliveryType::Immediate => WireDeliveryType::IMMEDIATE,

            DeliveryType::OnReadable => WireDeliveryType::ON_READABLE,

            DeliveryType::UnknownOrdinal_(value) => {
                WireDeliveryType { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[doc = " Declares a protocol capability backed by this component.\n\n To learn more about protocols, see:\n https://fuchsia.dev/fuchsia-src/glossary#protocol\n"]
#[derive(Clone, Debug, Default)]
pub struct Protocol {
    pub name: Option<String>,

    pub source_path: Option<String>,

    pub delivery: Option<crate::DeliveryType>,
}

impl Protocol {
    fn __max_ordinal(&self) -> usize {
        if self.delivery.is_some() {
            return 3;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for Protocol {
    type Encoded = WireProtocol<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireProtocol<'de>> for Protocol {
    #[inline]
    fn from_wire(wire: WireProtocol<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireProtocol<'static> {
    type Decoded<'de> = WireProtocol<'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 WireProtocol<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireProtocol<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn delivery(&self) -> Option<&crate::WireDeliveryType> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireProtocol<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Protocol")
            .field("name", &self.name())
            .field("source_path", &self.source_path())
            .field("delivery", &self.delivery())
            .finish()
    }
}

#[doc = " A reference to the environment.\n"]
#[derive(Clone, Debug)]
#[repr(C)]
pub struct EnvironmentRef {}

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

    type Encoded = WireEnvironmentRef;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for EnvironmentRef
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 EnvironmentRef
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 EnvironmentRef {
    type EncodedOption = ::fidl_next::WireBox<'static, WireEnvironmentRef>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for EnvironmentRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    EnvironmentRef: ::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 EnvironmentRef
where
    ___E: ::fidl_next::Encoder + ?Sized,
    EnvironmentRef: ::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<WireEnvironmentRef> for EnvironmentRef {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireEnvironmentRef, Self> =
        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireEnvironmentRef
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 = " A reference to a capability source or destination relative to this\n component.\n"]
#[derive(Clone, Debug)]
pub enum Ref {
    Parent(crate::ParentRef),

    Self_(crate::SelfRef),

    Child(crate::ChildRef),

    Collection(crate::CollectionRef),

    Framework(crate::FrameworkRef),

    Capability(crate::CapabilityRef),

    Debug(crate::DebugRef),

    VoidType(crate::VoidRef),

    Environment(crate::EnvironmentRef),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Ref {
    type Encoded = WireRef<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Ref
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 WireRef { raw, _phantom: _ } = out);

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

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

            Self::Child(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::ChildRef>(
                value, 3, encoder, raw,
            )?,

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

            Self::Framework(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::FrameworkRef,
            >(value, 5, encoder, raw)?,

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

            Self::Debug(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::DebugRef>(
                value, 7, encoder, raw,
            )?,

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

            Self::Environment(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::EnvironmentRef,
            >(value, 9, encoder, raw)?,

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Ref
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 WireRef { raw, _phantom: _ } = out);

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

            Self::Self_(value) => ::fidl_next::RawWireUnion::encode_as::<___E, &crate::SelfRef>(
                value, 2, encoder, raw,
            )?,

            Self::Child(value) => ::fidl_next::RawWireUnion::encode_as::<___E, &crate::ChildRef>(
                value, 3, encoder, raw,
            )?,

            Self::Collection(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::CollectionRef,
            >(value, 4, encoder, raw)?,

            Self::Framework(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::FrameworkRef,
            >(value, 5, encoder, raw)?,

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

            Self::Debug(value) => ::fidl_next::RawWireUnion::encode_as::<___E, &crate::DebugRef>(
                value, 7, encoder, raw,
            )?,

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

            Self::Environment(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::EnvironmentRef,
            >(value, 9, encoder, raw)?,

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Ref {
    type EncodedOption = WireOptionalRef<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Ref
where
    ___E: ?Sized,
    Ref: ::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 WireOptionalRef { 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 Ref
where
    ___E: ?Sized,
    Ref: ::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 WireOptionalRef { 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<WireRef<'de>> for Ref {
    #[inline]
    fn from_wire(wire: WireRef<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Parent(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireParentRef>()
            })),

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

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

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

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

            6 => Self::Capability(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireCapabilityRef<'de>>()
            })),

            7 => Self::Debug(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDebugRef>()
            })),

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

            9 => Self::Environment(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireEnvironmentRef>()
            })),

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

impl<'de> ::fidl_next::FromWireRef<WireRef<'de>> for Ref {
    #[inline]
    fn from_wire_ref(wire: &WireRef<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Parent(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireParentRef>()
            })),

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

            3 => Self::Child(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireChildRef<'de>>()
            })),

            4 => Self::Collection(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireCollectionRef<'de>>()
            })),

            5 => Self::Framework(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireFrameworkRef>()
            })),

            6 => Self::Capability(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireCapabilityRef<'de>>()
            })),

            7 => Self::Debug(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireDebugRef>()
            })),

            8 => Self::VoidType(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireVoidRef>()
            })),

            9 => Self::Environment(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireEnvironmentRef>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalRef<'de>> for Box<Ref> {
    #[inline]
    fn from_wire_option(wire: WireOptionalRef<'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<WireOptionalRef<'de>> for Box<Ref> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalRef<'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 [`Ref`].
#[repr(transparent)]
pub struct WireRef<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

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

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

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

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

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

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

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

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

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireRef<'static> {
    type Decoded<'de> = WireRef<'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 ref_ {
    pub enum Ref<'de> {
        Parent(&'de crate::WireParentRef),

        Self_(&'de crate::WireSelfRef),

        Child(&'de crate::WireChildRef<'de>),

        Collection(&'de crate::WireCollectionRef<'de>),

        Framework(&'de crate::WireFrameworkRef),

        Capability(&'de crate::WireCapabilityRef<'de>),

        Debug(&'de crate::WireDebugRef),

        VoidType(&'de crate::WireVoidRef),

        Environment(&'de crate::WireEnvironmentRef),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireRef<'de> {
    pub fn as_ref(&self) -> crate::ref_::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::ref_::Ref::Parent(unsafe {
                self.raw.get().deref_unchecked::<crate::WireParentRef>()
            }),

            2 => crate::ref_::Ref::Self_(unsafe {
                self.raw.get().deref_unchecked::<crate::WireSelfRef>()
            }),

            3 => crate::ref_::Ref::Child(unsafe {
                self.raw.get().deref_unchecked::<crate::WireChildRef<'_>>()
            }),

            4 => crate::ref_::Ref::Collection(unsafe {
                self.raw.get().deref_unchecked::<crate::WireCollectionRef<'_>>()
            }),

            5 => crate::ref_::Ref::Framework(unsafe {
                self.raw.get().deref_unchecked::<crate::WireFrameworkRef>()
            }),

            6 => crate::ref_::Ref::Capability(unsafe {
                self.raw.get().deref_unchecked::<crate::WireCapabilityRef<'_>>()
            }),

            7 => crate::ref_::Ref::Debug(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDebugRef>()
            }),

            8 => crate::ref_::Ref::VoidType(unsafe {
                self.raw.get().deref_unchecked::<crate::WireVoidRef>()
            }),

            9 => crate::ref_::Ref::Environment(unsafe {
                self.raw.get().deref_unchecked::<crate::WireEnvironmentRef>()
            }),

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireRef<'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, crate::WireParentRef>(raw, decoder)?,

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

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

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

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

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

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDebugRef>(raw, decoder)?,

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

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireEnvironmentRef>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireRef<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireParentRef>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireSelfRef>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireChildRef<'_>>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireCollectionRef<'_>>().fmt(f) },
            5 => unsafe { self.raw.get().deref_unchecked::<crate::WireFrameworkRef>().fmt(f) },
            6 => unsafe { self.raw.get().deref_unchecked::<crate::WireCapabilityRef<'_>>().fmt(f) },
            7 => unsafe { self.raw.get().deref_unchecked::<crate::WireDebugRef>().fmt(f) },
            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireVoidRef>().fmt(f) },
            9 => unsafe { self.raw.get().deref_unchecked::<crate::WireEnvironmentRef>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalRef<'static> {
    type Decoded<'de> = WireOptionalRef<'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> WireOptionalRef<'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<&WireRef<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalRef<'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, crate::WireParentRef>(raw, decoder)?,

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

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

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

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

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

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDebugRef>(raw, decoder)?,

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

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireEnvironmentRef>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

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

#[doc = " Declares a storage capability backed by a directory from which data, cache,\n or meta storage can be offered.\n"]
#[derive(Clone, Debug, Default)]
pub struct Storage {
    pub name: Option<String>,

    pub source: Option<crate::Ref>,

    pub backing_dir: Option<String>,

    pub subdir: Option<String>,

    pub storage_id: Option<crate::StorageId>,
}

impl Storage {
    fn __max_ordinal(&self) -> usize {
        if self.storage_id.is_some() {
            return 5;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Storage {
    type Encoded = WireStorage<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Storage
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireStorage { 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 {
                5 => {
                    if let Some(storage_id) = self.storage_id.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            storage_id,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Storage
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireStorage { 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 {
                5 => {
                    if let Some(storage_id) = &self.storage_id {
                        ::fidl_next::WireEnvelope::encode_value(
                            storage_id,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireStorage<'de>> for Storage {
    #[inline]
    fn from_wire(wire: WireStorage<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

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

            backing_dir: backing_dir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            subdir: subdir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

            backing_dir: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            subdir: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireStorage<'static> {
    type Decoded<'de> = WireStorage<'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 WireStorage<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    let backing_dir = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let subdir = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireStorage<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn backing_dir(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn subdir(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn storage_id(&self) -> Option<&crate::WireStorageId> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireStorage<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Storage")
            .field("name", &self.name())
            .field("source", &self.source())
            .field("backing_dir", &self.backing_dir())
            .field("subdir", &self.subdir())
            .field("storage_id", &self.storage_id())
            .finish()
    }
}

#[doc = " Declares a dictionary capability.\n"]
#[derive(Clone, Debug, Default)]
pub struct Dictionary {
    pub name: Option<String>,

    pub source: Option<crate::Ref>,

    pub source_dictionary: Option<String>,

    pub source_path: Option<String>,
}

impl Dictionary {
    fn __max_ordinal(&self) -> usize {
        if self.source_path.is_some() {
            return 4;
        }

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Dictionary {
    type Encoded = WireDictionary<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireDictionary<'de>> for Dictionary {
    #[inline]
    fn from_wire(wire: WireDictionary<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_path: source_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

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

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

            source_dictionary: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_path: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireDictionary<'static> {
    type Decoded<'de> = WireDictionary<'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 WireDictionary<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

impl<'de> WireDictionary<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn source_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDictionary<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Dictionary")
            .field("name", &self.name())
            .field("source", &self.source())
            .field("source_dictionary", &self.source_dictionary())
            .field("source_path", &self.source_path())
            .finish()
    }
}

#[doc = " Declares a capability defined by this component.\n"]
#[derive(Clone, Debug)]
pub enum Capability {
    Service(crate::Service),

    Protocol(crate::Protocol),

    Directory(crate::Directory),

    Storage(crate::Storage),

    Runner(crate::Runner),

    Resolver(crate::Resolver),

    EventStream(crate::EventStream),

    Dictionary(crate::Dictionary),

    Config(crate::Configuration),

    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,
{
    #[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::Service(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::Service>(
                value, 1, encoder, raw,
            )?,

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

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

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

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

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

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

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

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::Configuration,
            >(value, 10, encoder, raw)?,

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Capability
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 WireCapability { raw, _phantom: _ } = out);

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

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

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::Directory,
            >(value, 3, encoder, raw)?,

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

            Self::Runner(value) => ::fidl_next::RawWireUnion::encode_as::<___E, &crate::Runner>(
                value, 5, encoder, raw,
            )?,

            Self::Resolver(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &crate::Resolver>(
                    value, 6, encoder, raw,
                )?
            }

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

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

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::Configuration,
            >(value, 10, 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(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Capability
where
    ___E: ?Sized,
    Capability: ::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 WireOptionalCapability { 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<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::Service(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireService<'de>>()
            })),

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

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

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

            5 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireRunner<'de>>()
            })),

            6 => Self::Resolver(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireResolver<'de>>()
            })),

            8 => Self::EventStream(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireEventStream<'de>>()
            })),

            9 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDictionary<'de>>()
            })),

            10 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConfiguration<'de>>()
            })),

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

impl<'de> ::fidl_next::FromWireRef<WireCapability<'de>> for Capability {
    #[inline]
    fn from_wire_ref(wire: &WireCapability<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireService<'de>>()
            })),

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

            3 => Self::Directory(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireDirectory<'de>>()
            })),

            4 => Self::Storage(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireStorage<'de>>()
            })),

            5 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireRunner<'de>>()
            })),

            6 => Self::Resolver(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireResolver<'de>>()
            })),

            8 => Self::EventStream(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireEventStream<'de>>()
            })),

            9 => Self::Dictionary(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireDictionary<'de>>()
            })),

            10 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireConfiguration<'de>>()
            })),

            _ => 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
        }
    }
}

impl<'de> ::fidl_next::FromWireOptionRef<WireOptionalCapability<'de>> for Box<Capability> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalCapability<'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 [`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::WireService<'de>>() };
            }

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

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

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

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

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

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

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

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

            _ => (),
        }
    }
}

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> {
        Service(&'de crate::WireService<'de>),

        Protocol(&'de crate::WireProtocol<'de>),

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

        Storage(&'de crate::WireStorage<'de>),

        Runner(&'de crate::WireRunner<'de>),

        Resolver(&'de crate::WireResolver<'de>),

        EventStream(&'de crate::WireEventStream<'de>),

        Dictionary(&'de crate::WireDictionary<'de>),

        Config(&'de crate::WireConfiguration<'de>),

        UnknownOrdinal_(u64),
    }
}

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

            2 => crate::capability::Ref::Protocol(unsafe {
                self.raw.get().deref_unchecked::<crate::WireProtocol<'_>>()
            }),

            3 => crate::capability::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirectory<'_>>()
            }),

            4 => crate::capability::Ref::Storage(unsafe {
                self.raw.get().deref_unchecked::<crate::WireStorage<'_>>()
            }),

            5 => crate::capability::Ref::Runner(unsafe {
                self.raw.get().deref_unchecked::<crate::WireRunner<'_>>()
            }),

            6 => crate::capability::Ref::Resolver(unsafe {
                self.raw.get().deref_unchecked::<crate::WireResolver<'_>>()
            }),

            8 => crate::capability::Ref::EventStream(unsafe {
                self.raw.get().deref_unchecked::<crate::WireEventStream<'_>>()
            }),

            9 => crate::capability::Ref::Dictionary(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDictionary<'_>>()
            }),

            10 => crate::capability::Ref::Config(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfiguration<'_>>()
            }),

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

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

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

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

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

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

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfiguration<'static>>(
                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::WireService<'_>>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireProtocol<'_>>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirectory<'_>>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireStorage<'_>>().fmt(f) },
            5 => unsafe { self.raw.get().deref_unchecked::<crate::WireRunner<'_>>().fmt(f) },
            6 => unsafe { self.raw.get().deref_unchecked::<crate::WireResolver<'_>>().fmt(f) },
            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireEventStream<'_>>().fmt(f) },
            9 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionary<'_>>().fmt(f) },
            10 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfiguration<'_>>().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,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireService<'static>>(
                raw, decoder,
            )?,

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

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

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

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

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

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfiguration<'static>>(
                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 = " Describes under what conditions the component may be started.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum StartupMode {
    Lazy = 0,
    Eager = 1,
}

impl ::fidl_next::Encodable for StartupMode {
    type Encoded = WireStartupMode;
}
impl ::std::convert::TryFrom<u32> for StartupMode {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::Lazy),
            1 => Ok(Self::Eager),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for StartupMode
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 StartupMode
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 WireStartupMode { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Lazy => 0,

            Self::Eager => 1,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireStartupMode> for StartupMode {
    fn from(wire: WireStartupMode) -> Self {
        match u32::from(wire.value) {
            0 => Self::Lazy,

            1 => Self::Eager,

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

impl ::fidl_next::FromWire<WireStartupMode> for StartupMode {
    #[inline]
    fn from_wire(wire: WireStartupMode) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireStartupMode {
    pub const LAZY: WireStartupMode = WireStartupMode { value: ::fidl_next::WireU32(0) };

    pub const EAGER: WireStartupMode = WireStartupMode { value: ::fidl_next::WireU32(1) };
}

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

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

        Ok(())
    }
}

impl ::core::convert::From<StartupMode> for WireStartupMode {
    fn from(natural: StartupMode) -> Self {
        match natural {
            StartupMode::Lazy => WireStartupMode::LAZY,

            StartupMode::Eager => WireStartupMode::EAGER,
        }
    }
}

#[doc = " Describes the action to take if this component instance terminates\n unexpectedly.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum OnTerminate {
    None = 0,
    Reboot = 1,
}

impl ::fidl_next::Encodable for OnTerminate {
    type Encoded = WireOnTerminate;
}
impl ::std::convert::TryFrom<u32> for OnTerminate {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::None),
            1 => Ok(Self::Reboot),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for OnTerminate
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 OnTerminate
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 WireOnTerminate { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::None => 0,

            Self::Reboot => 1,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireOnTerminate> for OnTerminate {
    fn from(wire: WireOnTerminate) -> Self {
        match u32::from(wire.value) {
            0 => Self::None,

            1 => Self::Reboot,

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

impl ::fidl_next::FromWire<WireOnTerminate> for OnTerminate {
    #[inline]
    fn from_wire(wire: WireOnTerminate) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireOnTerminate {
    pub const NONE: WireOnTerminate = WireOnTerminate { value: ::fidl_next::WireU32(0) };

    pub const REBOOT: WireOnTerminate = WireOnTerminate { value: ::fidl_next::WireU32(1) };
}

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

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

        Ok(())
    }
}

impl ::core::convert::From<OnTerminate> for WireOnTerminate {
    fn from(natural: OnTerminate) -> Self {
        match natural {
            OnTerminate::None => WireOnTerminate::NONE,

            OnTerminate::Reboot => WireOnTerminate::REBOOT,
        }
    }
}

#[doc = " The string identifier for a config field.\n"]
pub type ConfigKey = String;

/// The wire type corresponding to [`ConfigKey`].
pub type WireConfigKey<'de> = ::fidl_next::WireString<'de>;

#[doc = " A directive to override the value of a particular configuration field in the child.\n"]
#[derive(Clone, Debug, Default)]
pub struct ConfigOverride {
    pub key: Option<String>,

    pub value: Option<crate::ConfigValue>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for ConfigOverride {
    type Encoded = WireConfigOverride<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigOverride
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigOverride { 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(value) = self.value.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigOverride
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigOverride { 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(value) = &self.value {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(key) = &self.key {
                        ::fidl_next::WireEnvelope::encode_value(
                            key,
                            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<WireConfigOverride<'de>> for ConfigOverride {
    #[inline]
    fn from_wire(wire: WireConfigOverride<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireConfigOverride<'static> {
    type Decoded<'de> = WireConfigOverride<'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 WireConfigOverride<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let key = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireConfigOverride<'de> {
    pub fn key(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[doc = " Statically declares a child component instance.\n"]
#[derive(Clone, Debug, Default)]
pub struct Child {
    pub name: Option<String>,

    pub url: Option<String>,

    pub startup: Option<crate::StartupMode>,

    pub environment: Option<String>,

    pub on_terminate: Option<crate::OnTerminate>,

    pub config_overrides: Option<Vec<crate::ConfigOverride>>,
}

impl Child {
    fn __max_ordinal(&self) -> usize {
        if self.config_overrides.is_some() {
            return 6;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Child {
    type Encoded = WireChild<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Child
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireChild { 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 {
                6 => {
                    if let Some(config_overrides) = self.config_overrides.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            config_overrides,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Child
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireChild { 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 {
                6 => {
                    if let Some(config_overrides) = &self.config_overrides {
                        ::fidl_next::WireEnvelope::encode_value(
                            config_overrides,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireChild<'de>> for Child {
    #[inline]
    fn from_wire(wire: WireChild<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

        Self {


                name: name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                url: url.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


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


                environment: environment.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


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


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

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireChild<'de>> for Child {
    #[inline]
    fn from_wire_ref(wire: &WireChild<'de>) -> Self {
        Self {


                name: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


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


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


                environment: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


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


                config_overrides: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigOverride<'de>>>() }
                    )),

        }
    }
}

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireChild<'static> {
    type Decoded<'de> = WireChild<'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 WireChild<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let url = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let environment = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireConfigOverride<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireChild<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn startup(&self) -> Option<&crate::WireStartupMode> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn environment(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn on_terminate(&self) -> Option<&crate::WireOnTerminate> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn config_overrides(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireConfigOverride<'de>>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireChild<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Child")
            .field("name", &self.name())
            .field("url", &self.url())
            .field("startup", &self.startup())
            .field("environment", &self.environment())
            .field("on_terminate", &self.on_terminate())
            .field("config_overrides", &self.config_overrides())
            .finish()
    }
}

#[doc = " The durability of component instances created in a collection.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum Durability {
    Transient = 2,
    SingleRun = 3,
}

impl ::fidl_next::Encodable for Durability {
    type Encoded = WireDurability;
}
impl ::std::convert::TryFrom<u32> for Durability {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            2 => Ok(Self::Transient),
            3 => Ok(Self::SingleRun),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for Durability
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 Durability
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 WireDurability { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Transient => 2,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDurability> for Durability {
    fn from(wire: WireDurability) -> Self {
        match u32::from(wire.value) {
            2 => Self::Transient,

            3 => Self::SingleRun,

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

impl ::fidl_next::FromWire<WireDurability> for Durability {
    #[inline]
    fn from_wire(wire: WireDurability) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireDurability {
    pub const TRANSIENT: WireDurability = WireDurability { value: ::fidl_next::WireU32(2) };

    pub const SINGLE_RUN: WireDurability = WireDurability { value: ::fidl_next::WireU32(3) };
}

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

        Ok(())
    }
}

impl ::core::convert::From<Durability> for WireDurability {
    fn from(natural: Durability) -> Self {
        match natural {
            Durability::Transient => WireDurability::TRANSIENT,

            Durability::SingleRun => WireDurability::SINGLE_RUN,
        }
    }
}

#[doc = " Statically declares a component instance collection.\n"]
#[derive(Clone, Debug, Default)]
pub struct Collection {
    pub name: Option<String>,

    pub durability: Option<crate::Durability>,

    pub environment: Option<String>,

    pub allowed_offers: Option<crate::AllowedOffers>,

    pub allow_long_names: Option<bool>,

    pub persistent_storage: Option<bool>,
}

impl Collection {
    fn __max_ordinal(&self) -> usize {
        if self.persistent_storage.is_some() {
            return 6;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Collection {
    type Encoded = WireCollection<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Collection
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireCollection { 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 {
                6 => {
                    if let Some(persistent_storage) = self.persistent_storage.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            persistent_storage,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Collection
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireCollection { 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 {
                6 => {
                    if let Some(persistent_storage) = &self.persistent_storage {
                        ::fidl_next::WireEnvelope::encode_value(
                            persistent_storage,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireCollection<'de>> for Collection {
    #[inline]
    fn from_wire(wire: WireCollection<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

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

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

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

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

            environment: environment.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

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

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

            environment: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireCollection<'static> {
    type Decoded<'de> = WireCollection<'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 WireCollection<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    let environment = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireCollection<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn environment(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn allowed_offers(&self) -> Option<&crate::WireAllowedOffers> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

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

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

impl<'de> ::core::fmt::Debug for WireCollection<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Collection")
            .field("name", &self.name())
            .field("durability", &self.durability())
            .field("environment", &self.environment())
            .field("allowed_offers", &self.allowed_offers())
            .field("allow_long_names", &self.allow_long_names())
            .field("persistent_storage", &self.persistent_storage())
            .finish()
    }
}

#[doc = " Describes the type of dependency implied by the capability.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum DependencyType {
    Strong = 1,
    Weak = 2,
}

impl ::fidl_next::Encodable for DependencyType {
    type Encoded = WireDependencyType;
}
impl ::std::convert::TryFrom<u32> for DependencyType {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Strong),
            2 => Ok(Self::Weak),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for DependencyType
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 DependencyType
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 WireDependencyType { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Strong => 1,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDependencyType> for DependencyType {
    fn from(wire: WireDependencyType) -> Self {
        match u32::from(wire.value) {
            1 => Self::Strong,

            2 => Self::Weak,

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

impl ::fidl_next::FromWire<WireDependencyType> for DependencyType {
    #[inline]
    fn from_wire(wire: WireDependencyType) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireDependencyType {
    pub const STRONG: WireDependencyType = WireDependencyType { value: ::fidl_next::WireU32(1) };

    pub const WEAK: WireDependencyType = WireDependencyType { value: ::fidl_next::WireU32(2) };
}

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

        Ok(())
    }
}

impl ::core::convert::From<DependencyType> for WireDependencyType {
    fn from(natural: DependencyType) -> Self {
        match natural {
            DependencyType::Strong => WireDependencyType::STRONG,

            DependencyType::Weak => WireDependencyType::WEAK,
        }
    }
}

#[doc = " Type used to create a mapping between 2 names. Used to rename service or component instances\n in FIDL declarations.\n"]
#[derive(Clone, Debug)]
pub struct NameMapping {
    pub source_name: String,

    pub target_name: String,
}

impl ::fidl_next::Encodable for NameMapping {
    type Encoded = WireNameMapping<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NameMapping
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 {
                source_name,
                target_name,

            } = out;
        }

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NameMapping
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 {
                source_name,
                target_name,

            } = out;
        }

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NameMapping
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NameMapping: ::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 NameMapping
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NameMapping: ::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<WireNameMapping<'de>> for NameMapping {
    #[inline]
    fn from_wire(wire: WireNameMapping<'de>) -> Self {
        Self {
            source_name: ::fidl_next::FromWire::from_wire(wire.source_name),

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

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

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNameMapping<'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 source_name,
                mut target_name,

            } = slot;
        }

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

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

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

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

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

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

        Ok(())
    }
}

#[doc = " Specifies how a declared environment\'s initial set of properties are assigned.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum EnvironmentExtends {
    None = 0,
    Realm = 1,
}

impl ::fidl_next::Encodable for EnvironmentExtends {
    type Encoded = WireEnvironmentExtends;
}
impl ::std::convert::TryFrom<u32> for EnvironmentExtends {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::None),
            1 => Ok(Self::Realm),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for EnvironmentExtends
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 EnvironmentExtends
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 WireEnvironmentExtends { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::None => 0,

            Self::Realm => 1,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireEnvironmentExtends> for EnvironmentExtends {
    fn from(wire: WireEnvironmentExtends) -> Self {
        match u32::from(wire.value) {
            0 => Self::None,

            1 => Self::Realm,

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

impl ::fidl_next::FromWire<WireEnvironmentExtends> for EnvironmentExtends {
    #[inline]
    fn from_wire(wire: WireEnvironmentExtends) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireEnvironmentExtends {
    pub const NONE: WireEnvironmentExtends =
        WireEnvironmentExtends { value: ::fidl_next::WireU32(0) };

    pub const REALM: WireEnvironmentExtends =
        WireEnvironmentExtends { value: ::fidl_next::WireU32(1) };
}

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

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

        Ok(())
    }
}

impl ::core::convert::From<EnvironmentExtends> for WireEnvironmentExtends {
    fn from(natural: EnvironmentExtends) -> Self {
        match natural {
            EnvironmentExtends::None => WireEnvironmentExtends::NONE,

            EnvironmentExtends::Realm => WireEnvironmentExtends::REALM,
        }
    }
}

pub const MAX_URL_SCHEME_LENGTH: u32 = 100;

pub type UrlScheme = String;

/// The wire type corresponding to [`UrlScheme`].
pub type WireUrlScheme<'de> = ::fidl_next::WireString<'de>;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum ConfigTypeLayout {
    Bool = 1,
    Uint8 = 2,
    Uint16 = 3,
    Uint32 = 4,
    Uint64 = 5,
    Int8 = 6,
    Int16 = 7,
    Int32 = 8,
    Int64 = 9,
    String = 10,
    Vector = 11,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for ConfigTypeLayout {
    type Encoded = WireConfigTypeLayout;
}
impl ::std::convert::From<u32> for ConfigTypeLayout {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::Bool,
            2 => Self::Uint8,
            3 => Self::Uint16,
            4 => Self::Uint32,
            5 => Self::Uint64,
            6 => Self::Int8,
            7 => Self::Int16,
            8 => Self::Int32,
            9 => Self::Int64,
            10 => Self::String,
            11 => Self::Vector,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigTypeLayout
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 ConfigTypeLayout
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 WireConfigTypeLayout { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Bool => 1,

            Self::Uint8 => 2,

            Self::Uint16 => 3,

            Self::Uint32 => 4,

            Self::Uint64 => 5,

            Self::Int8 => 6,

            Self::Int16 => 7,

            Self::Int32 => 8,

            Self::Int64 => 9,

            Self::String => 10,

            Self::Vector => 11,

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

        Ok(())
    }
}

impl ::core::convert::From<WireConfigTypeLayout> for ConfigTypeLayout {
    fn from(wire: WireConfigTypeLayout) -> Self {
        match u32::from(wire.value) {
            1 => Self::Bool,

            2 => Self::Uint8,

            3 => Self::Uint16,

            4 => Self::Uint32,

            5 => Self::Uint64,

            6 => Self::Int8,

            7 => Self::Int16,

            8 => Self::Int32,

            9 => Self::Int64,

            10 => Self::String,

            11 => Self::Vector,

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

impl ::fidl_next::FromWire<WireConfigTypeLayout> for ConfigTypeLayout {
    #[inline]
    fn from_wire(wire: WireConfigTypeLayout) -> Self {
        Self::from(wire)
    }
}

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

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

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

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

impl WireConfigTypeLayout {
    pub const BOOL: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(1) };

    pub const UINT8: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(2) };

    pub const UINT16: WireConfigTypeLayout =
        WireConfigTypeLayout { value: ::fidl_next::WireU32(3) };

    pub const UINT32: WireConfigTypeLayout =
        WireConfigTypeLayout { value: ::fidl_next::WireU32(4) };

    pub const UINT64: WireConfigTypeLayout =
        WireConfigTypeLayout { value: ::fidl_next::WireU32(5) };

    pub const INT8: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(6) };

    pub const INT16: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(7) };

    pub const INT32: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(8) };

    pub const INT64: WireConfigTypeLayout = WireConfigTypeLayout { value: ::fidl_next::WireU32(9) };

    pub const STRING: WireConfigTypeLayout =
        WireConfigTypeLayout { value: ::fidl_next::WireU32(10) };

    pub const VECTOR: WireConfigTypeLayout =
        WireConfigTypeLayout { value: ::fidl_next::WireU32(11) };
}

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

impl ::core::convert::From<ConfigTypeLayout> for WireConfigTypeLayout {
    fn from(natural: ConfigTypeLayout) -> Self {
        match natural {
            ConfigTypeLayout::Bool => WireConfigTypeLayout::BOOL,

            ConfigTypeLayout::Uint8 => WireConfigTypeLayout::UINT8,

            ConfigTypeLayout::Uint16 => WireConfigTypeLayout::UINT16,

            ConfigTypeLayout::Uint32 => WireConfigTypeLayout::UINT32,

            ConfigTypeLayout::Uint64 => WireConfigTypeLayout::UINT64,

            ConfigTypeLayout::Int8 => WireConfigTypeLayout::INT8,

            ConfigTypeLayout::Int16 => WireConfigTypeLayout::INT16,

            ConfigTypeLayout::Int32 => WireConfigTypeLayout::INT32,

            ConfigTypeLayout::Int64 => WireConfigTypeLayout::INT64,

            ConfigTypeLayout::String => WireConfigTypeLayout::STRING,

            ConfigTypeLayout::Vector => WireConfigTypeLayout::VECTOR,

            ConfigTypeLayout::UnknownOrdinal_(value) => {
                WireConfigTypeLayout { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[derive(Clone, Debug)]
pub enum LayoutConstraint {
    MaxSize(u32),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for LayoutConstraint {
    type Encoded = WireLayoutConstraint;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for LayoutConstraint
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 WireLayoutConstraint { raw, _phantom: _ } = out);

        match self {
            Self::MaxSize(value) => {
                ::fidl_next::RawWireUnion::encode_as_static::<___E, u32>(value, 1, encoder, raw)?
            }

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LayoutConstraint
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 WireLayoutConstraint { raw, _phantom: _ } = out);

        match self {
            Self::MaxSize(value) => {
                ::fidl_next::RawWireUnion::encode_as_static::<___E, &u32>(value, 1, encoder, raw)?
            }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for LayoutConstraint {
    type EncodedOption = WireOptionalLayoutConstraint;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LayoutConstraint
where
    ___E: ?Sized,
    LayoutConstraint: ::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 WireOptionalLayoutConstraint { 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 LayoutConstraint
where
    ___E: ?Sized,
    LayoutConstraint: ::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 WireOptionalLayoutConstraint { 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 ::fidl_next::FromWire<WireLayoutConstraint> for LayoutConstraint {
    #[inline]
    fn from_wire(wire: WireLayoutConstraint) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::MaxSize(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireU32>()
            })),

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

impl ::fidl_next::FromWireRef<WireLayoutConstraint> for LayoutConstraint {
    #[inline]
    fn from_wire_ref(wire: &WireLayoutConstraint) -> Self {
        match wire.raw.ordinal() {
            1 => Self::MaxSize(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            })),

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

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

impl ::fidl_next::FromWireOptionRef<WireOptionalLayoutConstraint> for Box<LayoutConstraint> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalLayoutConstraint) -> 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 [`LayoutConstraint`].
#[repr(transparent)]
pub struct WireLayoutConstraint {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

            _ => (),
        }
    }
}

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

    #[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 layout_constraint {
    pub enum Ref<'de> {
        MaxSize(&'de ::fidl_next::WireU32),

        UnknownOrdinal_(u64),
    }
}

impl WireLayoutConstraint {
    pub fn as_ref(&self) -> crate::layout_constraint::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::layout_constraint::Ref::MaxSize(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            }),

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

impl Clone for WireLayoutConstraint {
    fn clone(&self) -> Self {
        match self.raw.ordinal() {
            1 => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<::fidl_next::WireU32>() },
                _phantom: ::core::marker::PhantomData,
            },

            _ => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<()>() },
                _phantom: ::core::marker::PhantomData,
            },
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLayoutConstraint
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    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::WireU32>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

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

#[repr(transparent)]
pub struct WireOptionalLayoutConstraint {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

    #[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 WireOptionalLayoutConstraint {
    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<&WireLayoutConstraint> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

impl Clone for WireOptionalLayoutConstraint {
    fn clone(&self) -> Self {
        if self.is_none() {
            return WireOptionalLayoutConstraint {
                raw: ::fidl_next::RawWireUnion::absent(),
                _phantom: ::core::marker::PhantomData,
            };
        }

        match self.raw.ordinal() {
            1 => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<::fidl_next::WireU32>() },
                _phantom: ::core::marker::PhantomData,
            },

            _ => Self {
                raw: unsafe { self.raw.clone_inline_unchecked::<()>() },
                _phantom: ::core::marker::PhantomData,
            },
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalLayoutConstraint
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    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::WireU32>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

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

#[derive(Clone, Debug)]
pub struct ConfigType {
    pub layout: crate::ConfigTypeLayout,

    pub parameters: Option<Vec<crate::LayoutParameter>>,

    pub constraints: Vec<crate::LayoutConstraint>,
}

impl ::fidl_next::Encodable for ConfigType {
    type Encoded = WireConfigType<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigType
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 {
                layout,
                parameters,
                constraints,

            } = out;
        }

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

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigType
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 {
                layout,
                parameters,
                constraints,

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigType
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ConfigType: ::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 ConfigType
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ConfigType: ::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<WireConfigType<'de>> for ConfigType {
    #[inline]
    fn from_wire(wire: WireConfigType<'de>) -> Self {
        Self {
            layout: ::fidl_next::FromWire::from_wire(wire.layout),

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

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

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

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

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

/// The wire type corresponding to [`ConfigType`].
#[derive(Debug)]
#[repr(C)]
pub struct WireConfigType<'de> {
    pub layout: crate::WireConfigTypeLayout,

    pub parameters: ::fidl_next::WireOptionalVector<'de, crate::WireLayoutParameter<'de>>,

    pub constraints: ::fidl_next::WireVector<'de, crate::WireLayoutConstraint>,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigType<'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 layout,
                mut parameters,
                mut constraints,

            } = slot;
        }

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

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

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

        Ok(())
    }
}

#[doc = " The checksum produced for a configuration interface.\n Two configuration interfaces are the same if their checksums are the same.\n"]
#[derive(Clone, Debug)]
pub enum ConfigChecksum {
    Sha256([u8; 32]),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ConfigChecksum {
    type Encoded = WireConfigChecksum<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigChecksum
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 WireConfigChecksum { raw, _phantom: _ } = out);

        match self {
            Self::Sha256(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, [u8; 32]>(value, 1, encoder, raw)?
            }

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigChecksum
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 WireConfigChecksum { raw, _phantom: _ } = out);

        match self {
            Self::Sha256(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &[u8; 32]>(value, 1, encoder, raw)?
            }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ConfigChecksum {
    type EncodedOption = WireOptionalConfigChecksum<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigChecksum
where
    ___E: ?Sized,
    ConfigChecksum: ::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 WireOptionalConfigChecksum { 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 ConfigChecksum
where
    ___E: ?Sized,
    ConfigChecksum: ::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 WireOptionalConfigChecksum { 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<WireConfigChecksum<'de>> for ConfigChecksum {
    #[inline]
    fn from_wire(wire: WireConfigChecksum<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Sha256(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<[u8; 32]>()
            })),

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

impl<'de> ::fidl_next::FromWireRef<WireConfigChecksum<'de>> for ConfigChecksum {
    #[inline]
    fn from_wire_ref(wire: &WireConfigChecksum<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Sha256(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<[u8; 32]>()
            })),

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

impl<'de> ::fidl_next::FromWireOption<WireOptionalConfigChecksum<'de>> for Box<ConfigChecksum> {
    #[inline]
    fn from_wire_option(wire: WireOptionalConfigChecksum<'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<WireOptionalConfigChecksum<'de>> for Box<ConfigChecksum> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalConfigChecksum<'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 [`ConfigChecksum`].
#[repr(transparent)]
pub struct WireConfigChecksum<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireConfigChecksum<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<[u8; 32]>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireConfigChecksum<'static> {
    type Decoded<'de> = WireConfigChecksum<'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 config_checksum {
    pub enum Ref<'de> {
        Sha256(&'de [u8; 32]),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireConfigChecksum<'de> {
    pub fn as_ref(&self) -> crate::config_checksum::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::config_checksum::Ref::Sha256(unsafe {
                self.raw.get().deref_unchecked::<[u8; 32]>()
            }),

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigChecksum<'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, [u8; 32]>(raw, decoder)?,

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireConfigChecksum<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<[u8; 32]>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalConfigChecksum<'static> {
    type Decoded<'de> = WireOptionalConfigChecksum<'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> WireOptionalConfigChecksum<'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<&WireConfigChecksum<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigChecksum<'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, [u8; 32]>(raw, decoder)?,

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

        Ok(())
    }
}

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

#[doc = " Declares storage used by a component, which was offered to it.\n"]
#[derive(Clone, Debug, Default)]
pub struct UseStorage {
    pub source_name: Option<String>,

    pub target_path: Option<String>,

    pub availability: Option<crate::Availability>,
}

impl UseStorage {
    fn __max_ordinal(&self) -> usize {
        if self.availability.is_some() {
            return 3;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseStorage {
    type Encoded = WireUseStorage<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

                1 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            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<WireUseStorage<'de>> for UseStorage {
    #[inline]
    fn from_wire(wire: WireUseStorage<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

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

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

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

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

            target_path: target_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

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

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

            target_path: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseStorage`].
#[repr(C)]
pub struct WireUseStorage<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseStorage<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseStorage<'static> {
    type Decoded<'de> = WireUseStorage<'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 WireUseStorage<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_path.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_path.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseStorage<'de> {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseStorage<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseStorage")
            .field("source_name", &self.source_name())
            .field("target_path", &self.target_path())
            .field("availability", &self.availability())
            .finish()
    }
}

::fidl_next::bitflags! {
    #[doc = " Allowed sources for runtime overrides of a config field\'s value.\n"]#[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
    )]
    pub struct ConfigMutability: u32 {
        #[doc = " Allow parent components to provide overrides for the configuration field.\n"]const PARENT = 1;
        const _ = !0;
    }
}

impl ::fidl_next::Encodable for ConfigMutability {
    type Encoded = WireConfigMutability;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigMutability
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 ConfigMutability
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigMutability { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(self.bits()));
        Ok(())
    }
}

impl ::core::convert::From<WireConfigMutability> for ConfigMutability {
    fn from(wire: WireConfigMutability) -> Self {
        Self::from_bits_retain(u32::from(wire.value))
    }
}

impl ::fidl_next::FromWire<WireConfigMutability> for ConfigMutability {
    #[inline]
    fn from_wire(wire: WireConfigMutability) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireConfigMutability> for ConfigMutability {
    #[inline]
    fn from_wire_ref(wire: &WireConfigMutability) -> Self {
        Self::from(*wire)
    }
}

/// The wire type corresponding to [`ConfigMutability`].
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
pub struct WireConfigMutability {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::Wire for WireConfigMutability {
    type Decoded<'de> = Self;

    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire bits have no padding
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigMutability
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<ConfigMutability> for WireConfigMutability {
    fn from(natural: ConfigMutability) -> Self {
        Self { value: ::fidl_next::WireU32::from(natural.bits()) }
    }
}

#[doc = " Declares a single config field (key + type)\n"]
#[derive(Clone, Debug, Default)]
pub struct ConfigField {
    pub key: Option<String>,

    pub type_: Option<crate::ConfigType>,

    pub mutability: Option<crate::ConfigMutability>,
}

impl ConfigField {
    fn __max_ordinal(&self) -> usize {
        if self.mutability.is_some() {
            return 3;
        }

        if self.type_.is_some() {
            return 2;
        }

        if self.key.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigField {
    type Encoded = WireConfigField<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigField
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigField { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(mutability) = self.mutability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            mutability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(type_) = self.type_.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            type_,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(key) = self.key.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            key,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigField
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigField { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(mutability) = &self.mutability {
                        ::fidl_next::WireEnvelope::encode_value(
                            mutability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(type_) = &self.type_ {
                        ::fidl_next::WireEnvelope::encode_value(
                            type_,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(key) = &self.key {
                        ::fidl_next::WireEnvelope::encode_value(
                            key,
                            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<WireConfigField<'de>> for ConfigField {
    #[inline]
    fn from_wire(wire: WireConfigField<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let key = wire.table.get(1);

        let type_ = wire.table.get(2);

        let mutability = wire.table.get(3);

        Self {
            key: key.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            type_: type_.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConfigType<'de>>()
                })
            }),

            mutability: mutability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConfigMutability>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigField<'de>> for ConfigField {
    #[inline]
    fn from_wire_ref(wire: &WireConfigField<'de>) -> Self {
        Self {
            key: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            type_: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireConfigType<'de>>()
                })
            }),

            mutability: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireConfigMutability>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ConfigField`].
#[repr(C)]
pub struct WireConfigField<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireConfigField<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigType<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigMutability>() });
    }
}

unsafe impl ::fidl_next::Wire for WireConfigField<'static> {
    type Decoded<'de> = WireConfigField<'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 WireConfigField<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let key = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if key.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: key.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigType<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigMutability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireConfigField<'de> {
    pub fn key(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn type_(&self) -> Option<&crate::WireConfigType<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn mutability(&self) -> Option<&crate::WireConfigMutability> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireConfigField<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConfigField")
            .field("key", &self.key())
            .field("type_", &self.type_())
            .field("mutability", &self.mutability())
            .finish()
    }
}

#[doc = " A program declaration.\n\n This declaration is set by executable components to designate the runner to\n use and pass runner-specific program information to it.\n\n To learn more about runners, see:\n https://fuchsia.dev/fuchsia-src/glossary#runner\n"]
#[derive(Clone, Debug, Default)]
pub struct Program {
    pub runner: Option<String>,

    pub info: Option<::fidl_next_fuchsia_data::Dictionary>,
}

impl Program {
    fn __max_ordinal(&self) -> usize {
        if self.info.is_some() {
            return 2;
        }

        if self.runner.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Program {
    type Encoded = WireProgram<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Program
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireProgram { 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(info) = self.info.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            info,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(runner) = self.runner.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            runner,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Program
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireProgram { 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(info) = &self.info {
                        ::fidl_next::WireEnvelope::encode_value(
                            info,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(runner) = &self.runner {
                        ::fidl_next::WireEnvelope::encode_value(
                            runner,
                            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<WireProgram<'de>> for Program {
    #[inline]
    fn from_wire(wire: WireProgram<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let runner = wire.table.get(1);

        let info = wire.table.get(2);

        Self {
            runner: runner.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            info: info.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireProgram<'de>> for Program {
    #[inline]
    fn from_wire_ref(wire: &WireProgram<'de>) -> Self {
        Self {
            runner: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            info: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`Program`].
#[repr(C)]
pub struct WireProgram<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireProgram<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireProgram<'static> {
    type Decoded<'de> = WireProgram<'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 WireProgram<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let runner = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if runner.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: runner.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_data::WireDictionary<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireProgram<'de> {
    pub fn runner(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn info(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireProgram<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Program")
            .field("runner", &self.runner())
            .field("info", &self.info())
            .finish()
    }
}

#[doc = " Declares a service used by a component, which was offered to it.\n\n To learn more about services, see:\n https://fuchsia.dev/fuchsia-src/glossary#service\n"]
#[derive(Clone, Debug, Default)]
pub struct UseService {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target_path: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl UseService {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.dependency_type.is_some() {
            return 4;
        }

        if self.target_path.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseService {
    type Encoded = WireUseService<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseService { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = self.target_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseService { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = &self.target_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireUseService<'de>> for UseService {
    #[inline]
    fn from_wire(wire: WireUseService<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target_path = wire.table.get(3);

        let dependency_type = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: target_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseService<'de>> for UseService {
    #[inline]
    fn from_wire_ref(wire: &WireUseService<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseService`].
#[repr(C)]
pub struct WireUseService<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseService<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseService<'static> {
    type Decoded<'de> = WireUseService<'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 WireUseService<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_path.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_path.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseService<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseService<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseService")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target_path", &self.target_path())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a protocol used by a component, which was offered to it.\n\n A protocol is a service with a single instance, provided by a single FIDL\n protocol.\n"]
#[derive(Clone, Debug, Default)]
pub struct UseProtocol {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target_path: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl UseProtocol {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.dependency_type.is_some() {
            return 4;
        }

        if self.target_path.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseProtocol {
    type Encoded = WireUseProtocol<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseProtocol { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = self.target_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseProtocol { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = &self.target_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireUseProtocol<'de>> for UseProtocol {
    #[inline]
    fn from_wire(wire: WireUseProtocol<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target_path = wire.table.get(3);

        let dependency_type = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: target_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseProtocol<'de>> for UseProtocol {
    #[inline]
    fn from_wire_ref(wire: &WireUseProtocol<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseProtocol`].
#[repr(C)]
pub struct WireUseProtocol<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseProtocol<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseProtocol<'static> {
    type Decoded<'de> = WireUseProtocol<'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 WireUseProtocol<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_path.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_path.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseProtocol<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseProtocol<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseProtocol")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target_path", &self.target_path())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a directory used by a component, which was offered to it.\n"]
#[derive(Clone, Debug, Default)]
pub struct UseDirectory {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target_path: Option<String>,

    pub rights: Option<::fidl_next_fuchsia_io::Operations>,

    pub subdir: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl UseDirectory {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 8;
        }

        if self.availability.is_some() {
            return 7;
        }

        if self.dependency_type.is_some() {
            return 6;
        }

        if self.subdir.is_some() {
            return 5;
        }

        if self.rights.is_some() {
            return 4;
        }

        if self.target_path.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseDirectory {
    type Encoded = WireUseDirectory<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseDirectory { 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 {
                8 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(subdir) = self.subdir.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(rights) = self.rights.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = self.target_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseDirectory { 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 {
                8 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(subdir) = &self.subdir {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(rights) = &self.rights {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_path) = &self.target_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireUseDirectory<'de>> for UseDirectory {
    #[inline]
    fn from_wire(wire: WireUseDirectory<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target_path = wire.table.get(3);

        let rights = wire.table.get(4);

        let subdir = wire.table.get(5);

        let dependency_type = wire.table.get(6);

        let availability = wire.table.get(7);

        let source_dictionary = wire.table.get(8);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: target_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: rights.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: subdir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseDirectory<'de>> for UseDirectory {
    #[inline]
    fn from_wire_ref(wire: &WireUseDirectory<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_path: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(8).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseDirectory`].
#[repr(C)]
pub struct WireUseDirectory<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseDirectory<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
        });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(8)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseDirectory<'static> {
    type Decoded<'de> = WireUseDirectory<'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 WireUseDirectory<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_path.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_path.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_io::WireOperations,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let subdir = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if subdir.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: subdir.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseDirectory<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn rights(&self) -> Option<&::fidl_next_fuchsia_io::WireOperations> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn subdir(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseDirectory<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseDirectory")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target_path", &self.target_path())
            .field("rights", &self.rights())
            .field("subdir", &self.subdir())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares an EventStream used by a component.\n"]
#[derive(Clone, Debug, Default)]
pub struct UseEventStream {
    pub source_name: Option<String>,

    pub source: Option<crate::Ref>,

    pub scope: Option<Vec<crate::Ref>>,

    pub target_path: Option<String>,

    pub availability: Option<crate::Availability>,

    pub filter: Option<::fidl_next_fuchsia_data::Dictionary>,
}

impl UseEventStream {
    fn __max_ordinal(&self) -> usize {
        if self.filter.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_path.is_some() {
            return 4;
        }

        if self.scope.is_some() {
            return 3;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.source_name.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseEventStream {
    type Encoded = WireUseEventStream<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseEventStream
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseEventStream { 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 {
                6 => {
                    if let Some(filter) = self.filter.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            filter,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_path) = self.target_path.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(scope) = self.scope.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            scope,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseEventStream
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseEventStream { 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 {
                6 => {
                    if let Some(filter) = &self.filter {
                        ::fidl_next::WireEnvelope::encode_value(
                            filter,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_path) = &self.target_path {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_path,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(scope) = &self.scope {
                        ::fidl_next::WireEnvelope::encode_value(
                            scope,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            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<WireUseEventStream<'de>> for UseEventStream {
    #[inline]
    fn from_wire(wire: WireUseEventStream<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source_name = wire.table.get(1);

        let source = wire.table.get(2);

        let scope = wire.table.get(3);

        let target_path = wire.table.get(4);

        let availability = wire.table.get(5);

        let filter = wire.table.get(6);

        Self {
            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            scope: scope.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
                })
            }),

            target_path: target_path.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            filter: filter.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseEventStream<'de>> for UseEventStream {
    #[inline]
    fn from_wire_ref(wire: &WireUseEventStream<'de>) -> Self {
        Self {
            source_name: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            scope: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
                })
            }),

            target_path: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            filter: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseEventStream`].
#[repr(C)]
pub struct WireUseEventStream<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseEventStream<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
        });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireUseEventStream<'static> {
    type Decoded<'de> = WireUseEventStream<'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 WireUseEventStream<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireRef<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_path = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_path.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_path.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_data::WireDictionary<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseEventStream<'de> {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn scope(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireRef<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn filter(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseEventStream<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseEventStream")
            .field("source_name", &self.source_name())
            .field("source", &self.source())
            .field("scope", &self.scope())
            .field("target_path", &self.target_path())
            .field("availability", &self.availability())
            .field("filter", &self.filter())
            .finish()
    }
}

#[doc = " Declares runner used by a component.\n"]
#[derive(Clone, Debug, Default)]
pub struct UseRunner {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub source_dictionary: Option<String>,
}

impl UseRunner {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseRunner {
    type Encoded = WireUseRunner<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseRunner { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseRunner { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireUseRunner<'de>> for UseRunner {
    #[inline]
    fn from_wire(wire: WireUseRunner<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let source_dictionary = wire.table.get(3);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseRunner<'de>> for UseRunner {
    #[inline]
    fn from_wire_ref(wire: &WireUseRunner<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseRunner`].
#[repr(C)]
pub struct WireUseRunner<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseRunner<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseRunner<'static> {
    type Decoded<'de> = WireUseRunner<'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 WireUseRunner<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseRunner<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseRunner<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseRunner")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[derive(Clone, Debug, Default)]
pub struct UseConfiguration {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub type_: Option<crate::ConfigType>,

    pub default: Option<crate::ConfigValue>,

    pub source_dictionary: Option<String>,
}

impl UseConfiguration {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 7;
        }

        if self.default.is_some() {
            return 6;
        }

        if self.type_.is_some() {
            return 5;
        }

        if self.availability.is_some() {
            return 4;
        }

        if self.target_name.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for UseConfiguration {
    type Encoded = WireUseConfiguration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UseConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseConfiguration { 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 {
                7 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(default) = self.default.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            default,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(type_) = self.type_.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            type_,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for UseConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireUseConfiguration { 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 {
                7 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(default) = &self.default {
                        ::fidl_next::WireEnvelope::encode_value(
                            default,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(type_) = &self.type_ {
                        ::fidl_next::WireEnvelope::encode_value(
                            type_,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireUseConfiguration<'de>> for UseConfiguration {
    #[inline]
    fn from_wire(wire: WireUseConfiguration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target_name = wire.table.get(3);

        let availability = wire.table.get(4);

        let type_ = wire.table.get(5);

        let default = wire.table.get(6);

        let source_dictionary = wire.table.get(7);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            type_: type_.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConfigType<'de>>()
                })
            }),

            default: default.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConfigValue<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUseConfiguration<'de>> for UseConfiguration {
    #[inline]
    fn from_wire_ref(wire: &WireUseConfiguration<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_name: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            type_: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireConfigType<'de>>()
                })
            }),

            default: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireConfigValue<'de>>()
                })
            }),

            source_dictionary: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`UseConfiguration`].
#[repr(C)]
pub struct WireUseConfiguration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireUseConfiguration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigType<'de>>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigValue<'de>>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireUseConfiguration<'static> {
    type Decoded<'de> = WireUseConfiguration<'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 WireUseConfiguration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigType<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigValue<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireUseConfiguration<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn type_(&self) -> Option<&crate::WireConfigType<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn default(&self) -> Option<&crate::WireConfigValue<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireUseConfiguration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("UseConfiguration")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("type_", &self.type_())
            .field("default", &self.default())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a capability used by a component, which was offered to it.\n"]
#[derive(Clone, Debug)]
pub enum Use {
    Service(crate::UseService),

    Protocol(crate::UseProtocol),

    Directory(crate::UseDirectory),

    Storage(crate::UseStorage),

    EventStream(crate::UseEventStream),

    Runner(crate::UseRunner),

    Config(crate::UseConfiguration),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Use {
    type Encoded = WireUse<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Use
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 WireUse { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::UseService>(
                    value, 1, encoder, raw,
                )?
            }

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::UseProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::UseDirectory,
            >(value, 3, encoder, raw)?,

            Self::Storage(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::UseStorage>(
                    value, 4, encoder, raw,
                )?
            }

            Self::EventStream(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::UseEventStream,
            >(value, 7, encoder, raw)?,

            Self::Runner(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::UseRunner>(
                value, 8, encoder, raw,
            )?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::UseConfiguration,
            >(value, 9, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Use
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 WireUse { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &crate::UseService>(
                    value, 1, encoder, raw,
                )?
            }

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::UseProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::UseDirectory,
            >(value, 3, encoder, raw)?,

            Self::Storage(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &crate::UseStorage>(
                    value, 4, encoder, raw,
                )?
            }

            Self::EventStream(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::UseEventStream,
            >(value, 7, encoder, raw)?,

            Self::Runner(value) => ::fidl_next::RawWireUnion::encode_as::<___E, &crate::UseRunner>(
                value, 8, encoder, raw,
            )?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::UseConfiguration,
            >(value, 9, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Use {
    type EncodedOption = WireOptionalUse<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Use
where
    ___E: ?Sized,
    Use: ::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 WireOptionalUse { 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 Use
where
    ___E: ?Sized,
    Use: ::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 WireOptionalUse { 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<WireUse<'de>> for Use {
    #[inline]
    fn from_wire(wire: WireUse<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseDirectory<'de>>()
            })),

            4 => Self::Storage(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseStorage<'de>>()
            })),

            7 => Self::EventStream(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseEventStream<'de>>()
            })),

            8 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseRunner<'de>>()
            })),

            9 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireUseConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireUse<'de>> for Use {
    #[inline]
    fn from_wire_ref(wire: &WireUse<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseDirectory<'de>>()
            })),

            4 => Self::Storage(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseStorage<'de>>()
            })),

            7 => Self::EventStream(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseEventStream<'de>>()
            })),

            8 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseRunner<'de>>()
            })),

            9 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireUseConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalUse<'de>> for Box<Use> {
    #[inline]
    fn from_wire_option(wire: WireOptionalUse<'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<WireOptionalUse<'de>> for Box<Use> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalUse<'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 [`Use`].
#[repr(transparent)]
pub struct WireUse<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireUse<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUseService<'de>>() };
            }

            2 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUseProtocol<'de>>() };
            }

            3 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUseDirectory<'de>>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUseStorage<'de>>() };
            }

            7 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireUseEventStream<'de>>() };
            }

            8 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUseRunner<'de>>() };
            }

            9 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireUseConfiguration<'de>>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireUse<'static> {
    type Decoded<'de> = WireUse<'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 use_ {
    pub enum Ref<'de> {
        Service(&'de crate::WireUseService<'de>),

        Protocol(&'de crate::WireUseProtocol<'de>),

        Directory(&'de crate::WireUseDirectory<'de>),

        Storage(&'de crate::WireUseStorage<'de>),

        EventStream(&'de crate::WireUseEventStream<'de>),

        Runner(&'de crate::WireUseRunner<'de>),

        Config(&'de crate::WireUseConfiguration<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireUse<'de> {
    pub fn as_ref(&self) -> crate::use_::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::use_::Ref::Service(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseService<'_>>()
            }),

            2 => crate::use_::Ref::Protocol(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseProtocol<'_>>()
            }),

            3 => crate::use_::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseDirectory<'_>>()
            }),

            4 => crate::use_::Ref::Storage(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseStorage<'_>>()
            }),

            7 => crate::use_::Ref::EventStream(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseEventStream<'_>>()
            }),

            8 => crate::use_::Ref::Runner(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseRunner<'_>>()
            }),

            9 => crate::use_::Ref::Config(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseConfiguration<'_>>()
            }),

            unknown => crate::use_::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireUse<'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, crate::WireUseService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseStorage<'static>>(
                raw, decoder,
            )?,

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseEventStream<'static>>(
                raw, decoder,
            )?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseRunner<'static>>(
                raw, decoder,
            )?,

            9 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseConfiguration<'static>>(
                    raw, decoder,
                )?
            }

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireUse<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireUseService<'_>>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUseProtocol<'_>>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireUseDirectory<'_>>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireUseStorage<'_>>().fmt(f) },
            7 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseEventStream<'_>>().fmt(f)
            },
            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireUseRunner<'_>>().fmt(f) },
            9 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireUseConfiguration<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalUse<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalUse<'static> {
    type Decoded<'de> = WireOptionalUse<'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> WireOptionalUse<'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<&WireUse<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireUse<'de>> {
        if self.is_some() {
            Some(WireUse { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalUse<'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, crate::WireUseService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseStorage<'static>>(
                raw, decoder,
            )?,

            7 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseEventStream<'static>>(
                raw, decoder,
            )?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseRunner<'static>>(
                raw, decoder,
            )?,

            9 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUseConfiguration<'static>>(
                    raw, decoder,
                )?
            }

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalUse<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " Declares a service exposed to a component\'s containing realm, such as a\n service exposed by the component or one of its children at runtime.\n\n To learn more about services, see:\n https://fuchsia.dev/fuchsia-src/glossary#service\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeService {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl ExposeService {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeService {
    type Encoded = WireExposeService<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeService { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeService { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeService<'de>> for ExposeService {
    #[inline]
    fn from_wire(wire: WireExposeService<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeService<'de>> for ExposeService {
    #[inline]
    fn from_wire_ref(wire: &WireExposeService<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeService`].
#[repr(C)]
pub struct WireExposeService<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeService<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeService<'static> {
    type Decoded<'de> = WireExposeService<'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 WireExposeService<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeService<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeService<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeService")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a protocol exposed to a component\'s containing realm, such as\n a protocol exposed by the component or one of its children at runtime.\n\n To learn more about protocols, see:\n https://fuchsia.dev/fuchsia-src/glossary#protocol\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeProtocol {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl ExposeProtocol {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeProtocol {
    type Encoded = WireExposeProtocol<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeProtocol { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeProtocol { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeProtocol<'de>> for ExposeProtocol {
    #[inline]
    fn from_wire(wire: WireExposeProtocol<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeProtocol<'de>> for ExposeProtocol {
    #[inline]
    fn from_wire_ref(wire: &WireExposeProtocol<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeProtocol`].
#[repr(C)]
pub struct WireExposeProtocol<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeProtocol<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeProtocol<'static> {
    type Decoded<'de> = WireExposeProtocol<'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 WireExposeProtocol<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeProtocol<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeProtocol<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeProtocol")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a directory exposed to a component\'s containing realm, such as a\n directory exposed by the component or one of its children at runtime.\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeDirectory {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub rights: Option<::fidl_next_fuchsia_io::Operations>,

    pub subdir: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl ExposeDirectory {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 8;
        }

        if self.availability.is_some() {
            return 7;
        }

        if self.subdir.is_some() {
            return 6;
        }

        if self.rights.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeDirectory {
    type Encoded = WireExposeDirectory<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeDirectory { 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 {
                8 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(subdir) = self.subdir.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(rights) = self.rights.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeDirectory { 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 {
                8 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(subdir) = &self.subdir {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(rights) = &self.rights {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeDirectory<'de>> for ExposeDirectory {
    #[inline]
    fn from_wire(wire: WireExposeDirectory<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let rights = wire.table.get(5);

        let subdir = wire.table.get(6);

        let availability = wire.table.get(7);

        let source_dictionary = wire.table.get(8);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: rights.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: subdir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeDirectory<'de>> for ExposeDirectory {
    #[inline]
    fn from_wire_ref(wire: &WireExposeDirectory<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(8).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeDirectory`].
#[repr(C)]
pub struct WireExposeDirectory<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeDirectory<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
        });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(8)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeDirectory<'static> {
    type Decoded<'de> = WireExposeDirectory<'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 WireExposeDirectory<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_io::WireOperations,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let subdir = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if subdir.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: subdir.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeDirectory<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn rights(&self) -> Option<&::fidl_next_fuchsia_io::WireOperations> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn subdir(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeDirectory<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeDirectory")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("rights", &self.rights())
            .field("subdir", &self.subdir())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a runner exposed to a component\'s containing realm, such as a\n runner exposed by the component or one of its children at runtime.\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeRunner {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub source_dictionary: Option<String>,
}

impl ExposeRunner {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeRunner {
    type Encoded = WireExposeRunner<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeRunner { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeRunner { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeRunner<'de>> for ExposeRunner {
    #[inline]
    fn from_wire(wire: WireExposeRunner<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeRunner<'de>> for ExposeRunner {
    #[inline]
    fn from_wire_ref(wire: &WireExposeRunner<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeRunner`].
#[repr(C)]
pub struct WireExposeRunner<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeRunner<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeRunner<'static> {
    type Decoded<'de> = WireExposeRunner<'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 WireExposeRunner<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeRunner<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeRunner<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeRunner")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a resolver exposed to a component\'s containing realm, such as a\n resolver exposed by the component or one of its children at runtime.\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeResolver {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub source_dictionary: Option<String>,
}

impl ExposeResolver {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeResolver {
    type Encoded = WireExposeResolver<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeResolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeResolver { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeResolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeResolver { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeResolver<'de>> for ExposeResolver {
    #[inline]
    fn from_wire(wire: WireExposeResolver<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeResolver<'de>> for ExposeResolver {
    #[inline]
    fn from_wire_ref(wire: &WireExposeResolver<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeResolver`].
#[repr(C)]
pub struct WireExposeResolver<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeResolver<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeResolver<'static> {
    type Decoded<'de> = WireExposeResolver<'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 WireExposeResolver<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeResolver<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeResolver<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeResolver")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a dictionary exposed to a component\'s containing realm, such as\n a dictionary exposed by the component or one of its children at runtime.\n\n To learn more about dictionarys, see:\n https://fuchsia.dev/fuchsia-src/glossary#dictionary\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeDictionary {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl ExposeDictionary {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeDictionary {
    type Encoded = WireExposeDictionary<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeDictionary
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeDictionary { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeDictionary
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeDictionary { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeDictionary<'de>> for ExposeDictionary {
    #[inline]
    fn from_wire(wire: WireExposeDictionary<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeDictionary<'de>> for ExposeDictionary {
    #[inline]
    fn from_wire_ref(wire: &WireExposeDictionary<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeDictionary`].
#[repr(C)]
pub struct WireExposeDictionary<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeDictionary<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeDictionary<'static> {
    type Decoded<'de> = WireExposeDictionary<'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 WireExposeDictionary<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeDictionary<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeDictionary<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeDictionary")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a configuration capability exposed to a component\'s containing realm, such as\n a capability exposed by the component or one of its children at runtime.\n"]
#[derive(Clone, Debug, Default)]
pub struct ExposeConfiguration {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl ExposeConfiguration {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ExposeConfiguration {
    type Encoded = WireExposeConfiguration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ExposeConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeConfiguration { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ExposeConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireExposeConfiguration { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireExposeConfiguration<'de>> for ExposeConfiguration {
    #[inline]
    fn from_wire(wire: WireExposeConfiguration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExposeConfiguration<'de>> for ExposeConfiguration {
    #[inline]
    fn from_wire_ref(wire: &WireExposeConfiguration<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ExposeConfiguration`].
#[repr(C)]
pub struct WireExposeConfiguration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireExposeConfiguration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireExposeConfiguration<'static> {
    type Decoded<'de> = WireExposeConfiguration<'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 WireExposeConfiguration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireExposeConfiguration<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireExposeConfiguration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ExposeConfiguration")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a capability exposed to either a component\'s containing realm or to\n the framework. For example, a legacy service exposed by the component at\n runtime.\n"]
#[derive(Clone, Debug)]
pub enum Expose {
    Service(crate::ExposeService),

    Protocol(crate::ExposeProtocol),

    Directory(crate::ExposeDirectory),

    Runner(crate::ExposeRunner),

    Resolver(crate::ExposeResolver),

    Dictionary(crate::ExposeDictionary),

    Config(crate::ExposeConfiguration),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Expose {
    type Encoded = WireExpose<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Expose
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 WireExpose { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeService,
            >(value, 1, encoder, raw)?,

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeDirectory,
            >(value, 3, encoder, raw)?,

            Self::Runner(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::ExposeRunner>(
                    value, 4, encoder, raw,
                )?
            }

            Self::Resolver(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeResolver,
            >(value, 5, encoder, raw)?,

            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeDictionary,
            >(value, 7, encoder, raw)?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ExposeConfiguration,
            >(value, 8, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Expose
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 WireExpose { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeService,
            >(value, 1, encoder, raw)?,

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeDirectory,
            >(value, 3, encoder, raw)?,

            Self::Runner(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeRunner,
            >(value, 4, encoder, raw)?,

            Self::Resolver(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeResolver,
            >(value, 5, encoder, raw)?,

            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeDictionary,
            >(value, 7, encoder, raw)?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ExposeConfiguration,
            >(value, 8, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Expose {
    type EncodedOption = WireOptionalExpose<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Expose
where
    ___E: ?Sized,
    Expose: ::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 WireOptionalExpose { 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 Expose
where
    ___E: ?Sized,
    Expose: ::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 WireOptionalExpose { 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<WireExpose<'de>> for Expose {
    #[inline]
    fn from_wire(wire: WireExpose<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeDirectory<'de>>()
            })),

            4 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeRunner<'de>>()
            })),

            5 => Self::Resolver(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeResolver<'de>>()
            })),

            7 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeDictionary<'de>>()
            })),

            8 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireExposeConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireExpose<'de>> for Expose {
    #[inline]
    fn from_wire_ref(wire: &WireExpose<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeDirectory<'de>>()
            })),

            4 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeRunner<'de>>()
            })),

            5 => Self::Resolver(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeResolver<'de>>()
            })),

            7 => Self::Dictionary(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeDictionary<'de>>()
            })),

            8 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireExposeConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalExpose<'de>> for Box<Expose> {
    #[inline]
    fn from_wire_option(wire: WireOptionalExpose<'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<WireOptionalExpose<'de>> for Box<Expose> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalExpose<'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 [`Expose`].
#[repr(transparent)]
pub struct WireExpose<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireExpose<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireExposeService<'de>>() };
            }

            2 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireExposeProtocol<'de>>() };
            }

            3 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireExposeDirectory<'de>>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireExposeRunner<'de>>() };
            }

            5 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireExposeResolver<'de>>() };
            }

            7 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireExposeDictionary<'de>>() };
            }

            8 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<crate::WireExposeConfiguration<'de>>()
                };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireExpose<'static> {
    type Decoded<'de> = WireExpose<'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 expose {
    pub enum Ref<'de> {
        Service(&'de crate::WireExposeService<'de>),

        Protocol(&'de crate::WireExposeProtocol<'de>),

        Directory(&'de crate::WireExposeDirectory<'de>),

        Runner(&'de crate::WireExposeRunner<'de>),

        Resolver(&'de crate::WireExposeResolver<'de>),

        Dictionary(&'de crate::WireExposeDictionary<'de>),

        Config(&'de crate::WireExposeConfiguration<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireExpose<'de> {
    pub fn as_ref(&self) -> crate::expose::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::expose::Ref::Service(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeService<'_>>()
            }),

            2 => crate::expose::Ref::Protocol(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeProtocol<'_>>()
            }),

            3 => crate::expose::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeDirectory<'_>>()
            }),

            4 => crate::expose::Ref::Runner(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeRunner<'_>>()
            }),

            5 => crate::expose::Ref::Resolver(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeResolver<'_>>()
            }),

            7 => crate::expose::Ref::Dictionary(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeDictionary<'_>>()
            }),

            8 => crate::expose::Ref::Config(unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeConfiguration<'_>>()
            }),

            unknown => crate::expose::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireExpose<'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, crate::WireExposeService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeRunner<'static>>(
                raw, decoder,
            )?,

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeResolver<'static>>(
                raw, decoder,
            )?,

            7 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeDictionary<'static>>(
                    raw, decoder,
                )?
            }

            8 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireExposeConfiguration<'static>,
            >(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireExpose<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireExposeService<'_>>().fmt(f) },
            2 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeProtocol<'_>>().fmt(f)
            },
            3 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeDirectory<'_>>().fmt(f)
            },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireExposeRunner<'_>>().fmt(f) },
            5 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeResolver<'_>>().fmt(f)
            },
            7 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeDictionary<'_>>().fmt(f)
            },
            8 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireExposeConfiguration<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalExpose<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalExpose<'static> {
    type Decoded<'de> = WireOptionalExpose<'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> WireOptionalExpose<'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<&WireExpose<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireExpose<'de>> {
        if self.is_some() {
            Some(WireExpose { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalExpose<'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, crate::WireExposeService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeRunner<'static>>(
                raw, decoder,
            )?,

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeResolver<'static>>(
                raw, decoder,
            )?,

            7 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireExposeDictionary<'static>>(
                    raw, decoder,
                )?
            }

            8 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireExposeConfiguration<'static>,
            >(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalExpose<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " Declares a service offered by a component to one of its children, which may\n have been offered by the component\'s containing realm, the component itself,\n or one of its other children.\n\n To learn more about services, see:\n https://fuchsia.dev/fuchsia-src/glossary#service\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferService {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub source_instance_filter: Option<Vec<String>>,

    pub renamed_instances: Option<Vec<crate::NameMapping>>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,
}

impl OfferService {
    fn __max_ordinal(&self) -> usize {
        if self.dependency_type.is_some() {
            return 9;
        }

        if self.source_dictionary.is_some() {
            return 8;
        }

        if self.availability.is_some() {
            return 7;
        }

        if self.renamed_instances.is_some() {
            return 6;
        }

        if self.source_instance_filter.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferService {
    type Encoded = WireOfferService<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferService { 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 {
                9 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(renamed_instances) = self.renamed_instances.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            renamed_instances,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(source_instance_filter) = self.source_instance_filter.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_instance_filter,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferService
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferService { 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 {
                9 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(renamed_instances) = &self.renamed_instances {
                        ::fidl_next::WireEnvelope::encode_value(
                            renamed_instances,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(source_instance_filter) = &self.source_instance_filter {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_instance_filter,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferService<'de>> for OfferService {
    #[inline]
    fn from_wire(wire: WireOfferService<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let source_instance_filter = wire.table.get(5);

        let renamed_instances = wire.table.get(6);

        let availability = wire.table.get(7);

        let source_dictionary = wire.table.get(8);

        let dependency_type = wire.table.get(9);

        Self {


                source: source.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() }
                )),


                source_name: source_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                target: target.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() }
                )),


                target_name: target_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                source_instance_filter: source_instance_filter.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>() }
                )),


                renamed_instances: renamed_instances.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNameMapping<'de>>>() }
                )),


                availability: availability.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireAvailability>() }
                )),


                source_dictionary: source_dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                dependency_type: dependency_type.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireDependencyType>() }
                )),

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferService<'de>> for OfferService {
    #[inline]
    fn from_wire_ref(wire: &WireOfferService<'de>) -> Self {
        Self {


                source: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireRef<'de>>() }
                    )),


                source_name: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


                target: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireRef<'de>>() }
                    )),


                target_name: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


                source_instance_filter: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>() }
                    )),


                renamed_instances: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireNameMapping<'de>>>() }
                    )),


                availability: wire.table.get(7)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireAvailability>() }
                    )),


                source_dictionary: wire.table.get(8)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


                dependency_type: wire.table.get(9)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireDependencyType>() }
                    )),

        }
    }
}

/// The wire type corresponding to [`OfferService`].
#[repr(C)]
pub struct WireOfferService<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferService<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>()
        });

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNameMapping<'de>>>()
        });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(8)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(9)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferService<'static> {
    type Decoded<'de> = WireOfferService<'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 WireOfferService<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNameMapping<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferService<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_instance_filter(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn renamed_instances(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireNameMapping<'de>>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferService<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferService")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("source_instance_filter", &self.source_instance_filter())
            .field("renamed_instances", &self.renamed_instances())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .field("dependency_type", &self.dependency_type())
            .finish()
    }
}

#[doc = " Declares a protocol offered by a component to one of its children,\n which may have been offered by the component\'s containing realm, the\n component itself, or one of its other children.\n\n To learn more about protocols, see:\n https://fuchsia.dev/fuchsia-src/glossary#protocol\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferProtocol {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl OfferProtocol {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 7;
        }

        if self.availability.is_some() {
            return 6;
        }

        if self.dependency_type.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferProtocol {
    type Encoded = WireOfferProtocol<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferProtocol { 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 {
                7 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferProtocol
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferProtocol { 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 {
                7 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferProtocol<'de>> for OfferProtocol {
    #[inline]
    fn from_wire(wire: WireOfferProtocol<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let dependency_type = wire.table.get(5);

        let availability = wire.table.get(6);

        let source_dictionary = wire.table.get(7);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferProtocol<'de>> for OfferProtocol {
    #[inline]
    fn from_wire_ref(wire: &WireOfferProtocol<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferProtocol`].
#[repr(C)]
pub struct WireOfferProtocol<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferProtocol<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferProtocol<'static> {
    type Decoded<'de> = WireOfferProtocol<'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 WireOfferProtocol<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferProtocol<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferProtocol<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferProtocol")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a directory offered by a component to one of its children, which\n may have been offered by the component\'s containing realm, the component\n itself, or one of its other children.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferDirectory {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub rights: Option<::fidl_next_fuchsia_io::Operations>,

    pub subdir: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl OfferDirectory {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 9;
        }

        if self.availability.is_some() {
            return 8;
        }

        if self.dependency_type.is_some() {
            return 7;
        }

        if self.subdir.is_some() {
            return 6;
        }

        if self.rights.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferDirectory {
    type Encoded = WireOfferDirectory<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferDirectory { 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 {
                9 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(subdir) = self.subdir.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(rights) = self.rights.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferDirectory
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferDirectory { 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 {
                9 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(subdir) = &self.subdir {
                        ::fidl_next::WireEnvelope::encode_value(
                            subdir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(rights) = &self.rights {
                        ::fidl_next::WireEnvelope::encode_value(
                            rights,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferDirectory<'de>> for OfferDirectory {
    #[inline]
    fn from_wire(wire: WireOfferDirectory<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let rights = wire.table.get(5);

        let subdir = wire.table.get(6);

        let dependency_type = wire.table.get(7);

        let availability = wire.table.get(8);

        let source_dictionary = wire.table.get(9);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: rights.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: subdir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferDirectory<'de>> for OfferDirectory {
    #[inline]
    fn from_wire_ref(wire: &WireOfferDirectory<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            rights: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
                })
            }),

            subdir: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(8).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(9).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferDirectory`].
#[repr(C)]
pub struct WireOfferDirectory<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferDirectory<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_io::WireOperations>()
        });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(8)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(9)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferDirectory<'static> {
    type Decoded<'de> = WireOfferDirectory<'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 WireOfferDirectory<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_io::WireOperations,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let subdir = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if subdir.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: subdir.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferDirectory<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn rights(&self) -> Option<&::fidl_next_fuchsia_io::WireOperations> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn subdir(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferDirectory<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferDirectory")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("rights", &self.rights())
            .field("subdir", &self.subdir())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a storage capability offered by a component to one of its children,\n such as meta storage offered by the component\'s containing realm or cache\n storage offered by the component itself.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferStorage {
    pub source_name: Option<String>,

    pub source: Option<crate::Ref>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,
}

impl OfferStorage {
    fn __max_ordinal(&self) -> usize {
        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.source_name.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferStorage {
    type Encoded = WireOfferStorage<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferStorage
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferStorage { 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 {
                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferStorage
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferStorage { 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 {
                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            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<WireOfferStorage<'de>> for OfferStorage {
    #[inline]
    fn from_wire(wire: WireOfferStorage<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source_name = wire.table.get(1);

        let source = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        Self {
            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferStorage<'de>> for OfferStorage {
    #[inline]
    fn from_wire_ref(wire: &WireOfferStorage<'de>) -> Self {
        Self {
            source_name: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferStorage`].
#[repr(C)]
pub struct WireOfferStorage<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferStorage<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferStorage<'static> {
    type Decoded<'de> = WireOfferStorage<'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 WireOfferStorage<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferStorage<'de> {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferStorage<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferStorage")
            .field("source_name", &self.source_name())
            .field("source", &self.source())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .finish()
    }
}

#[doc = " Declares a runner offered by a component to one of its children, which may\n have been offered by the component\'s containing realm, the component itself,\n or one of its other children.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferRunner {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub source_dictionary: Option<String>,
}

impl OfferRunner {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferRunner {
    type Encoded = WireOfferRunner<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferRunner { 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 {
                5 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferRunner
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferRunner { 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 {
                5 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferRunner<'de>> for OfferRunner {
    #[inline]
    fn from_wire(wire: WireOfferRunner<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let source_dictionary = wire.table.get(5);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferRunner<'de>> for OfferRunner {
    #[inline]
    fn from_wire_ref(wire: &WireOfferRunner<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferRunner`].
#[repr(C)]
pub struct WireOfferRunner<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferRunner<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferRunner<'static> {
    type Decoded<'de> = WireOfferRunner<'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 WireOfferRunner<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferRunner<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferRunner<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferRunner")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a resolver capability offered by a component to one of its children, which\n may have been offered by the component\'s containing realm, the component itself,\n or one of its other children.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferResolver {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub source_dictionary: Option<String>,
}

impl OfferResolver {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferResolver {
    type Encoded = WireOfferResolver<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferResolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferResolver { 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 {
                5 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferResolver
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferResolver { 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 {
                5 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferResolver<'de>> for OfferResolver {
    #[inline]
    fn from_wire(wire: WireOfferResolver<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let source_dictionary = wire.table.get(5);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferResolver<'de>> for OfferResolver {
    #[inline]
    fn from_wire_ref(wire: &WireOfferResolver<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source_dictionary: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferResolver`].
#[repr(C)]
pub struct WireOfferResolver<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferResolver<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferResolver<'static> {
    type Decoded<'de> = WireOfferResolver<'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 WireOfferResolver<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferResolver<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferResolver<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferResolver")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares an event stream offered by a component.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferEventStream {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub scope: Option<Vec<crate::Ref>>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,
}

impl OfferEventStream {
    fn __max_ordinal(&self) -> usize {
        if self.availability.is_some() {
            return 7;
        }

        if self.target_name.is_some() {
            return 5;
        }

        if self.target.is_some() {
            return 4;
        }

        if self.scope.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferEventStream {
    type Encoded = WireOfferEventStream<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferEventStream
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferEventStream { 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 {
                7 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(scope) = self.scope.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            scope,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferEventStream
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferEventStream { 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 {
                7 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(scope) = &self.scope {
                        ::fidl_next::WireEnvelope::encode_value(
                            scope,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferEventStream<'de>> for OfferEventStream {
    #[inline]
    fn from_wire(wire: WireOfferEventStream<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let scope = wire.table.get(3);

        let target = wire.table.get(4);

        let target_name = wire.table.get(5);

        let availability = wire.table.get(7);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            scope: scope.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferEventStream<'de>> for OfferEventStream {
    #[inline]
    fn from_wire_ref(wire: &WireOfferEventStream<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            scope: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
                })
            }),

            target: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferEventStream`].
#[repr(C)]
pub struct WireOfferEventStream<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferEventStream<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireRef<'de>>>()
        });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferEventStream<'static> {
    type Decoded<'de> = WireOfferEventStream<'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 WireOfferEventStream<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireRef<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferEventStream<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn scope(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireRef<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferEventStream<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferEventStream")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("scope", &self.scope())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .finish()
    }
}

#[doc = " Declares a dictionary offered by a component to one of its children,\n which may have been offered by the component\'s containing realm, the\n component itself, or one of its other children.\n\n To learn more about dictionaries, see:\n https://fuchsia.dev/fuchsia-src/glossary#dictionary\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferDictionary {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub dependency_type: Option<crate::DependencyType>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl OfferDictionary {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 7;
        }

        if self.availability.is_some() {
            return 6;
        }

        if self.dependency_type.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferDictionary {
    type Encoded = WireOfferDictionary<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferDictionary
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferDictionary { 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 {
                7 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(dependency_type) = self.dependency_type.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferDictionary
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferDictionary { 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 {
                7 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(dependency_type) = &self.dependency_type {
                        ::fidl_next::WireEnvelope::encode_value(
                            dependency_type,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferDictionary<'de>> for OfferDictionary {
    #[inline]
    fn from_wire(wire: WireOfferDictionary<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let dependency_type = wire.table.get(5);

        let availability = wire.table.get(6);

        let source_dictionary = wire.table.get(7);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: dependency_type.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferDictionary<'de>> for OfferDictionary {
    #[inline]
    fn from_wire_ref(wire: &WireOfferDictionary<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            dependency_type: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireDependencyType>()
                })
            }),

            availability: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(7).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferDictionary`].
#[repr(C)]
pub struct WireOfferDictionary<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferDictionary<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDependencyType>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferDictionary<'static> {
    type Decoded<'de> = WireOfferDictionary<'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 WireOfferDictionary<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDependencyType>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferDictionary<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn dependency_type(&self) -> Option<&crate::WireDependencyType> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferDictionary<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferDictionary")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("dependency_type", &self.dependency_type())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a configuration capability offered by a component to one of its children,\n which may have been offered by the component\'s containing realm, the\n component itself, or one of its other children.\n"]
#[derive(Clone, Debug, Default)]
pub struct OfferConfiguration {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target: Option<crate::Ref>,

    pub target_name: Option<String>,

    pub availability: Option<crate::Availability>,

    pub source_dictionary: Option<String>,
}

impl OfferConfiguration {
    fn __max_ordinal(&self) -> usize {
        if self.source_dictionary.is_some() {
            return 6;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferConfiguration {
    type Encoded = WireOfferConfiguration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OfferConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferConfiguration { 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 {
                6 => {
                    if let Some(source_dictionary) = self.source_dictionary.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = self.availability.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = self.target.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for OfferConfiguration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOfferConfiguration { 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 {
                6 => {
                    if let Some(source_dictionary) = &self.source_dictionary {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_dictionary,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(availability) = &self.availability {
                        ::fidl_next::WireEnvelope::encode_value(
                            availability,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(target) = &self.target {
                        ::fidl_next::WireEnvelope::encode_value(
                            target,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireOfferConfiguration<'de>> for OfferConfiguration {
    #[inline]
    fn from_wire(wire: WireOfferConfiguration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target = wire.table.get(3);

        let target_name = wire.table.get(4);

        let availability = wire.table.get(5);

        let source_dictionary = wire.table.get(6);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: target.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: availability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: source_dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOfferConfiguration<'de>> for OfferConfiguration {
    #[inline]
    fn from_wire_ref(wire: &WireOfferConfiguration<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(4).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            availability: wire.table.get(5).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireAvailability>()
                })
            }),

            source_dictionary: wire.table.get(6).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`OfferConfiguration`].
#[repr(C)]
pub struct WireOfferConfiguration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireOfferConfiguration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(4)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireAvailability>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireOfferConfiguration<'static> {
    type Decoded<'de> = WireOfferConfiguration<'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 WireOfferConfiguration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireAvailability>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_dictionary = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_dictionary.len() > 1024 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_dictionary.len() as u64,
                            limit: 1024,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireOfferConfiguration<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireOfferConfiguration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("OfferConfiguration")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target", &self.target())
            .field("target_name", &self.target_name())
            .field("availability", &self.availability())
            .field("source_dictionary", &self.source_dictionary())
            .finish()
    }
}

#[doc = " Declares a capability offered by a component to one of its children, which\n may have been offered by the component\'s containing realm, the component\n itself, or one of its other children.\n"]
#[derive(Clone, Debug)]
pub enum Offer {
    Service(crate::OfferService),

    Protocol(crate::OfferProtocol),

    Directory(crate::OfferDirectory),

    Storage(crate::OfferStorage),

    Runner(crate::OfferRunner),

    Resolver(crate::OfferResolver),

    EventStream(crate::OfferEventStream),

    Dictionary(crate::OfferDictionary),

    Config(crate::OfferConfiguration),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Offer {
    type Encoded = WireOffer<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Offer
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 WireOffer { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferService,
            >(value, 1, encoder, raw)?,

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferDirectory,
            >(value, 3, encoder, raw)?,

            Self::Storage(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferStorage,
            >(value, 4, encoder, raw)?,

            Self::Runner(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, crate::OfferRunner>(
                    value, 5, encoder, raw,
                )?
            }

            Self::Resolver(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferResolver,
            >(value, 6, encoder, raw)?,

            Self::EventStream(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferEventStream,
            >(value, 8, encoder, raw)?,

            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferDictionary,
            >(value, 9, encoder, raw)?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::OfferConfiguration,
            >(value, 10, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Offer
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 WireOffer { raw, _phantom: _ } = out);

        match self {
            Self::Service(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferService,
            >(value, 1, encoder, raw)?,

            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferProtocol,
            >(value, 2, encoder, raw)?,

            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferDirectory,
            >(value, 3, encoder, raw)?,

            Self::Storage(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferStorage,
            >(value, 4, encoder, raw)?,

            Self::Runner(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &crate::OfferRunner>(
                    value, 5, encoder, raw,
                )?
            }

            Self::Resolver(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferResolver,
            >(value, 6, encoder, raw)?,

            Self::EventStream(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferEventStream,
            >(value, 8, encoder, raw)?,

            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferDictionary,
            >(value, 9, encoder, raw)?,

            Self::Config(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::OfferConfiguration,
            >(value, 10, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Offer {
    type EncodedOption = WireOptionalOffer<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Offer
where
    ___E: ?Sized,
    Offer: ::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 WireOptionalOffer { 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 Offer
where
    ___E: ?Sized,
    Offer: ::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 WireOptionalOffer { 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<WireOffer<'de>> for Offer {
    #[inline]
    fn from_wire(wire: WireOffer<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferDirectory<'de>>()
            })),

            4 => Self::Storage(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferStorage<'de>>()
            })),

            5 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferRunner<'de>>()
            })),

            6 => Self::Resolver(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferResolver<'de>>()
            })),

            8 => Self::EventStream(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferEventStream<'de>>()
            })),

            9 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferDictionary<'de>>()
            })),

            10 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireOfferConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOffer<'de>> for Offer {
    #[inline]
    fn from_wire_ref(wire: &WireOffer<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Service(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferService<'de>>()
            })),

            2 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferProtocol<'de>>()
            })),

            3 => Self::Directory(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferDirectory<'de>>()
            })),

            4 => Self::Storage(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferStorage<'de>>()
            })),

            5 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferRunner<'de>>()
            })),

            6 => Self::Resolver(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferResolver<'de>>()
            })),

            8 => Self::EventStream(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferEventStream<'de>>()
            })),

            9 => Self::Dictionary(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferDictionary<'de>>()
            })),

            10 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireOfferConfiguration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalOffer<'de>> for Box<Offer> {
    #[inline]
    fn from_wire_option(wire: WireOptionalOffer<'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<WireOptionalOffer<'de>> for Box<Offer> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalOffer<'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 [`Offer`].
#[repr(transparent)]
pub struct WireOffer<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireOffer<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireOfferService<'de>>() };
            }

            2 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireOfferProtocol<'de>>() };
            }

            3 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireOfferDirectory<'de>>() };
            }

            4 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireOfferStorage<'de>>() };
            }

            5 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireOfferRunner<'de>>() };
            }

            6 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireOfferResolver<'de>>() };
            }

            8 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireOfferEventStream<'de>>() };
            }

            9 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireOfferDictionary<'de>>() };
            }

            10 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<crate::WireOfferConfiguration<'de>>()
                };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireOffer<'static> {
    type Decoded<'de> = WireOffer<'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 offer {
    pub enum Ref<'de> {
        Service(&'de crate::WireOfferService<'de>),

        Protocol(&'de crate::WireOfferProtocol<'de>),

        Directory(&'de crate::WireOfferDirectory<'de>),

        Storage(&'de crate::WireOfferStorage<'de>),

        Runner(&'de crate::WireOfferRunner<'de>),

        Resolver(&'de crate::WireOfferResolver<'de>),

        EventStream(&'de crate::WireOfferEventStream<'de>),

        Dictionary(&'de crate::WireOfferDictionary<'de>),

        Config(&'de crate::WireOfferConfiguration<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireOffer<'de> {
    pub fn as_ref(&self) -> crate::offer::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::offer::Ref::Service(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferService<'_>>()
            }),

            2 => crate::offer::Ref::Protocol(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferProtocol<'_>>()
            }),

            3 => crate::offer::Ref::Directory(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferDirectory<'_>>()
            }),

            4 => crate::offer::Ref::Storage(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferStorage<'_>>()
            }),

            5 => crate::offer::Ref::Runner(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferRunner<'_>>()
            }),

            6 => crate::offer::Ref::Resolver(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferResolver<'_>>()
            }),

            8 => crate::offer::Ref::EventStream(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferEventStream<'_>>()
            }),

            9 => crate::offer::Ref::Dictionary(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferDictionary<'_>>()
            }),

            10 => crate::offer::Ref::Config(unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferConfiguration<'_>>()
            }),

            unknown => crate::offer::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOffer<'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, crate::WireOfferService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferStorage<'static>>(
                raw, decoder,
            )?,

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferRunner<'static>>(
                raw, decoder,
            )?,

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferResolver<'static>>(
                raw, decoder,
            )?,

            8 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferEventStream<'static>>(
                    raw, decoder,
                )?
            }

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDictionary<'static>>(
                raw, decoder,
            )?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireOfferConfiguration<'static>,
            >(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOffer<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireOfferService<'_>>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireOfferProtocol<'_>>().fmt(f) },
            3 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferDirectory<'_>>().fmt(f)
            },
            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireOfferStorage<'_>>().fmt(f) },
            5 => unsafe { self.raw.get().deref_unchecked::<crate::WireOfferRunner<'_>>().fmt(f) },
            6 => unsafe { self.raw.get().deref_unchecked::<crate::WireOfferResolver<'_>>().fmt(f) },
            8 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferEventStream<'_>>().fmt(f)
            },
            9 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferDictionary<'_>>().fmt(f)
            },
            10 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireOfferConfiguration<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalOffer<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalOffer<'static> {
    type Decoded<'de> = WireOptionalOffer<'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> WireOptionalOffer<'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<&WireOffer<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireOffer<'de>> {
        if self.is_some() {
            Some(WireOffer { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalOffer<'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, crate::WireOfferService<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferProtocol<'static>>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDirectory<'static>>(
                raw, decoder,
            )?,

            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferStorage<'static>>(
                raw, decoder,
            )?,

            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferRunner<'static>>(
                raw, decoder,
            )?,

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferResolver<'static>>(
                raw, decoder,
            )?,

            8 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferEventStream<'static>>(
                    raw, decoder,
                )?
            }

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDictionary<'static>>(
                raw, decoder,
            )?,

            10 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireOfferConfiguration<'static>,
            >(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalOffer<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " A repository of the runners available in an environment.\n"]
#[derive(Clone, Debug, Default)]
pub struct RunnerRegistration {
    pub source_name: Option<String>,

    pub source: Option<crate::Ref>,

    pub target_name: Option<String>,
}

impl RunnerRegistration {
    fn __max_ordinal(&self) -> usize {
        if self.target_name.is_some() {
            return 3;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.source_name.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for RunnerRegistration {
    type Encoded = WireRunnerRegistration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for RunnerRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRunnerRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RunnerRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireRunnerRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            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<WireRunnerRegistration<'de>> for RunnerRegistration {
    #[inline]
    fn from_wire(wire: WireRunnerRegistration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source_name = wire.table.get(1);

        let source = wire.table.get(2);

        let target_name = wire.table.get(3);

        Self {
            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireRunnerRegistration<'de>> for RunnerRegistration {
    #[inline]
    fn from_wire_ref(wire: &WireRunnerRegistration<'de>) -> Self {
        Self {
            source_name: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            target_name: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`RunnerRegistration`].
#[repr(C)]
pub struct WireRunnerRegistration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireRunnerRegistration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireRunnerRegistration<'static> {
    type Decoded<'de> = WireRunnerRegistration<'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 WireRunnerRegistration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireRunnerRegistration<'de> {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireRunnerRegistration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("RunnerRegistration")
            .field("source_name", &self.source_name())
            .field("source", &self.source())
            .field("target_name", &self.target_name())
            .finish()
    }
}

#[doc = " A mapping of URL scheme to resolver name.\n"]
#[derive(Clone, Debug, Default)]
pub struct ResolverRegistration {
    pub resolver: Option<String>,

    pub source: Option<crate::Ref>,

    pub scheme: Option<String>,
}

impl ResolverRegistration {
    fn __max_ordinal(&self) -> usize {
        if self.scheme.is_some() {
            return 3;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.resolver.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ResolverRegistration {
    type Encoded = WireResolverRegistration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolverRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireResolverRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(scheme) = self.scheme.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            scheme,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(resolver) = self.resolver.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            resolver,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ResolverRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireResolverRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(scheme) = &self.scheme {
                        ::fidl_next::WireEnvelope::encode_value(
                            scheme,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(resolver) = &self.resolver {
                        ::fidl_next::WireEnvelope::encode_value(
                            resolver,
                            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<WireResolverRegistration<'de>> for ResolverRegistration {
    #[inline]
    fn from_wire(wire: WireResolverRegistration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let resolver = wire.table.get(1);

        let source = wire.table.get(2);

        let scheme = wire.table.get(3);

        Self {
            resolver: resolver.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            scheme: scheme.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireResolverRegistration<'de>> for ResolverRegistration {
    #[inline]
    fn from_wire_ref(wire: &WireResolverRegistration<'de>) -> Self {
        Self {
            resolver: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            source: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            scheme: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ResolverRegistration`].
#[repr(C)]
pub struct WireResolverRegistration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireResolverRegistration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireResolverRegistration<'static> {
    type Decoded<'de> = WireResolverRegistration<'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 WireResolverRegistration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let resolver = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if resolver.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: resolver.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let scheme = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if scheme.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: scheme.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireResolverRegistration<'de> {
    pub fn resolver(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn scheme(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireResolverRegistration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ResolverRegistration")
            .field("resolver", &self.resolver())
            .field("source", &self.source())
            .field("scheme", &self.scheme())
            .finish()
    }
}

#[doc = " Registers a protocol in the environment as a debug capability. This makes\n it available to any component in the environment that uses it with\n `source == debug`.\n\n To learn more about protocols, see:\n https://fuchsia.dev/fuchsia-src/glossary#protocol\n"]
#[derive(Clone, Debug, Default)]
pub struct DebugProtocolRegistration {
    pub source: Option<crate::Ref>,

    pub source_name: Option<String>,

    pub target_name: Option<String>,
}

impl DebugProtocolRegistration {
    fn __max_ordinal(&self) -> usize {
        if self.target_name.is_some() {
            return 3;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.source.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for DebugProtocolRegistration {
    type Encoded = WireDebugProtocolRegistration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DebugProtocolRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDebugProtocolRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = self.target_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = self.source_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = self.source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DebugProtocolRegistration
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDebugProtocolRegistration { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = &self.target_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            target_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(source_name) = &self.source_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            source_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(source) = &self.source {
                        ::fidl_next::WireEnvelope::encode_value(
                            source,
                            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<WireDebugProtocolRegistration<'de>> for DebugProtocolRegistration {
    #[inline]
    fn from_wire(wire: WireDebugProtocolRegistration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let source = wire.table.get(1);

        let source_name = wire.table.get(2);

        let target_name = wire.table.get(3);

        Self {
            source: source.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: source_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_name: target_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireDebugProtocolRegistration<'de>>
    for DebugProtocolRegistration
{
    #[inline]
    fn from_wire_ref(wire: &WireDebugProtocolRegistration<'de>) -> Self {
        Self {
            source: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireRef<'de>>()
                })
            }),

            source_name: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            target_name: wire.table.get(3).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`DebugProtocolRegistration`].
#[repr(C)]
pub struct WireDebugProtocolRegistration<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireDebugProtocolRegistration<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireRef<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireDebugProtocolRegistration<'static> {
    type Decoded<'de> = WireDebugProtocolRegistration<'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 WireDebugProtocolRegistration<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireRef<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let source_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if source_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: source_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let target_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if target_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: target_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireDebugProtocolRegistration<'de> {
    pub fn source(&self) -> Option<&crate::WireRef<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDebugProtocolRegistration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DebugProtocolRegistration")
            .field("source", &self.source())
            .field("source_name", &self.source_name())
            .field("target_name", &self.target_name())
            .finish()
    }
}

#[doc = " Declares a capability registered in the debug section of an environment.\n"]
#[derive(Clone, Debug)]
pub enum DebugRegistration {
    Protocol(crate::DebugProtocolRegistration),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for DebugRegistration {
    type Encoded = WireDebugRegistration<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DebugRegistration
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 WireDebugRegistration { raw, _phantom: _ } = out);

        match self {
            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DebugProtocolRegistration,
            >(value, 1, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DebugRegistration
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 WireDebugRegistration { raw, _phantom: _ } = out);

        match self {
            Self::Protocol(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::DebugProtocolRegistration,
            >(value, 1, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DebugRegistration {
    type EncodedOption = WireOptionalDebugRegistration<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DebugRegistration
where
    ___E: ?Sized,
    DebugRegistration: ::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 WireOptionalDebugRegistration { 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 DebugRegistration
where
    ___E: ?Sized,
    DebugRegistration: ::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 WireOptionalDebugRegistration { 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<WireDebugRegistration<'de>> for DebugRegistration {
    #[inline]
    fn from_wire(wire: WireDebugRegistration<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireDebugProtocolRegistration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireDebugRegistration<'de>> for DebugRegistration {
    #[inline]
    fn from_wire_ref(wire: &WireDebugRegistration<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireDebugProtocolRegistration<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalDebugRegistration<'de>>
    for Box<DebugRegistration>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalDebugRegistration<'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<WireOptionalDebugRegistration<'de>>
    for Box<DebugRegistration>
{
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalDebugRegistration<'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 [`DebugRegistration`].
#[repr(transparent)]
pub struct WireDebugRegistration<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireDebugRegistration<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<crate::WireDebugProtocolRegistration<'de>>()
                };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireDebugRegistration<'static> {
    type Decoded<'de> = WireDebugRegistration<'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 debug_registration {
    pub enum Ref<'de> {
        Protocol(&'de crate::WireDebugProtocolRegistration<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireDebugRegistration<'de> {
    pub fn as_ref(&self) -> crate::debug_registration::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::debug_registration::Ref::Protocol(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDebugProtocolRegistration<'_>>()
            }),

            unknown => crate::debug_registration::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDebugRegistration<'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,
                crate::WireDebugProtocolRegistration<'static>,
            >(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireDebugRegistration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireDebugProtocolRegistration<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalDebugRegistration<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalDebugRegistration<'static> {
    type Decoded<'de> = WireOptionalDebugRegistration<'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> WireOptionalDebugRegistration<'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<&WireDebugRegistration<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireDebugRegistration<'de>> {
        if self.is_some() {
            Some(WireDebugRegistration { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDebugRegistration<'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,
                crate::WireDebugProtocolRegistration<'static>,
            >(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalDebugRegistration<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " Declares an environment which configures a realm.\n"]
#[derive(Clone, Debug, Default)]
pub struct Environment {
    pub name: Option<String>,

    pub extends: Option<crate::EnvironmentExtends>,

    pub runners: Option<Vec<crate::RunnerRegistration>>,

    pub resolvers: Option<Vec<crate::ResolverRegistration>>,

    pub debug_capabilities: Option<Vec<crate::DebugRegistration>>,

    pub stop_timeout_ms: Option<u32>,
}

impl Environment {
    fn __max_ordinal(&self) -> usize {
        if self.stop_timeout_ms.is_some() {
            return 6;
        }

        if self.debug_capabilities.is_some() {
            return 5;
        }

        if self.resolvers.is_some() {
            return 4;
        }

        if self.runners.is_some() {
            return 3;
        }

        if self.extends.is_some() {
            return 2;
        }

        if self.name.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Environment {
    type Encoded = WireEnvironment<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Environment
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireEnvironment { 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 {
                6 => {
                    if let Some(stop_timeout_ms) = self.stop_timeout_ms.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            stop_timeout_ms,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(debug_capabilities) = self.debug_capabilities.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            debug_capabilities,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(resolvers) = self.resolvers.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            resolvers,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(runners) = self.runners.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            runners,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(extends) = self.extends.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            extends,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = self.name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Environment
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireEnvironment { 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 {
                6 => {
                    if let Some(stop_timeout_ms) = &self.stop_timeout_ms {
                        ::fidl_next::WireEnvelope::encode_value(
                            stop_timeout_ms,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(debug_capabilities) = &self.debug_capabilities {
                        ::fidl_next::WireEnvelope::encode_value(
                            debug_capabilities,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(resolvers) = &self.resolvers {
                        ::fidl_next::WireEnvelope::encode_value(
                            resolvers,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(runners) = &self.runners {
                        ::fidl_next::WireEnvelope::encode_value(
                            runners,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(extends) = &self.extends {
                        ::fidl_next::WireEnvelope::encode_value(
                            extends,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = &self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            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<WireEnvironment<'de>> for Environment {
    #[inline]
    fn from_wire(wire: WireEnvironment<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let name = wire.table.get(1);

        let extends = wire.table.get(2);

        let runners = wire.table.get(3);

        let resolvers = wire.table.get(4);

        let debug_capabilities = wire.table.get(5);

        let stop_timeout_ms = wire.table.get(6);

        Self {


                name: name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                extends: extends.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireEnvironmentExtends>() }
                )),


                runners: runners.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireRunnerRegistration<'de>>>() }
                )),


                resolvers: resolvers.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireResolverRegistration<'de>>>() }
                )),


                debug_capabilities: debug_capabilities.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireDebugRegistration<'de>>>() }
                )),


                stop_timeout_ms: stop_timeout_ms.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() }
                )),

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireEnvironment<'de>> for Environment {
    #[inline]
    fn from_wire_ref(wire: &WireEnvironment<'de>) -> Self {
        Self {


                name: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireString<'de>>() }
                    )),


                extends: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireEnvironmentExtends>() }
                    )),


                runners: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireRunnerRegistration<'de>>>() }
                    )),


                resolvers: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireResolverRegistration<'de>>>() }
                    )),


                debug_capabilities: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireDebugRegistration<'de>>>() }
                    )),


                stop_timeout_ms: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireU32>() }
                    )),

        }
    }
}

/// The wire type corresponding to [`Environment`].
#[repr(C)]
pub struct WireEnvironment<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireEnvironment<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireEnvironmentExtends>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope
                .read_unchecked::<::fidl_next::WireVector<'de, crate::WireRunnerRegistration<'de>>>(
                )
        });

        let _ = self.table.get(4)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireResolverRegistration<'de>>>()
                });

        let _ = self.table.get(5)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireDebugRegistration<'de>>>()
                });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU32>() });
    }
}

unsafe impl ::fidl_next::Wire for WireEnvironment<'static> {
    type Decoded<'de> = WireEnvironment<'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 WireEnvironment<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireEnvironmentExtends>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireRunnerRegistration<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireResolverRegistration<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireDebugRegistration<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU32>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireEnvironment<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn extends(&self) -> Option<&crate::WireEnvironmentExtends> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn runners(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireRunnerRegistration<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn resolvers(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireResolverRegistration<'de>>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn debug_capabilities(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireDebugRegistration<'de>>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn stop_timeout_ms(&self) -> Option<&::fidl_next::WireU32> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireEnvironment<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Environment")
            .field("name", &self.name())
            .field("extends", &self.extends())
            .field("runners", &self.runners())
            .field("resolvers", &self.resolvers())
            .field("debug_capabilities", &self.debug_capabilities())
            .field("stop_timeout_ms", &self.stop_timeout_ms())
            .finish()
    }
}

#[derive(Clone, Debug, Default)]
pub struct ConfigSourceCapabilities {}

impl ConfigSourceCapabilities {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for ConfigSourceCapabilities {
    type Encoded = WireConfigSourceCapabilities<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigSourceCapabilities
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigSourceCapabilities { 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 {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigSourceCapabilities
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigSourceCapabilities { 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 {
                _ => ::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<WireConfigSourceCapabilities<'de>> for ConfigSourceCapabilities {
    #[inline]
    fn from_wire(wire: WireConfigSourceCapabilities<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        Self {}
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigSourceCapabilities<'de>> for ConfigSourceCapabilities {
    #[inline]
    fn from_wire_ref(wire: &WireConfigSourceCapabilities<'de>) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`ConfigSourceCapabilities`].
#[repr(C)]
pub struct WireConfigSourceCapabilities<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireConfigSourceCapabilities<'de> {
    fn drop(&mut self) {}
}

unsafe impl ::fidl_next::Wire for WireConfigSourceCapabilities<'static> {
    type Decoded<'de> = WireConfigSourceCapabilities<'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 WireConfigSourceCapabilities<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireConfigSourceCapabilities<'de> {}

impl<'de> ::core::fmt::Debug for WireConfigSourceCapabilities<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConfigSourceCapabilities").finish()
    }
}

#[doc = " Strategies available for resolving configuration values.\n"]
#[derive(Clone, Debug)]
pub enum ConfigValueSource {
    PackagePath(String),

    Capabilities(crate::ConfigSourceCapabilities),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for ConfigValueSource {
    type Encoded = WireConfigValueSource<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigValueSource
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 WireConfigValueSource { raw, _phantom: _ } = out);

        match self {
            Self::PackagePath(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, String>(value, 1, encoder, raw)?
            }

            Self::Capabilities(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ConfigSourceCapabilities,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigValueSource
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 WireConfigValueSource { raw, _phantom: _ } = out);

        match self {
            Self::PackagePath(value) => {
                ::fidl_next::RawWireUnion::encode_as::<___E, &String>(value, 1, encoder, raw)?
            }

            Self::Capabilities(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ConfigSourceCapabilities,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ConfigValueSource {
    type EncodedOption = WireOptionalConfigValueSource<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConfigValueSource
where
    ___E: ?Sized,
    ConfigValueSource: ::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 WireOptionalConfigValueSource { 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 ConfigValueSource
where
    ___E: ?Sized,
    ConfigValueSource: ::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 WireOptionalConfigValueSource { 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<WireConfigValueSource<'de>> for ConfigValueSource {
    #[inline]
    fn from_wire(wire: WireConfigValueSource<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::PackagePath(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::WireString<'de>>()
            })),

            2 => Self::Capabilities(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConfigSourceCapabilities<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigValueSource<'de>> for ConfigValueSource {
    #[inline]
    fn from_wire_ref(wire: &WireConfigValueSource<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::PackagePath(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
            })),

            2 => Self::Capabilities(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireConfigSourceCapabilities<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalConfigValueSource<'de>>
    for Box<ConfigValueSource>
{
    #[inline]
    fn from_wire_option(wire: WireOptionalConfigValueSource<'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<WireOptionalConfigValueSource<'de>>
    for Box<ConfigValueSource>
{
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalConfigValueSource<'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 [`ConfigValueSource`].
#[repr(transparent)]
pub struct WireConfigValueSource<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireConfigValueSource<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireString<'de>>() };
            }

            2 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<crate::WireConfigSourceCapabilities<'de>>()
                };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireConfigValueSource<'static> {
    type Decoded<'de> = WireConfigValueSource<'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 config_value_source {
    pub enum Ref<'de> {
        PackagePath(&'de ::fidl_next::WireString<'de>),

        Capabilities(&'de crate::WireConfigSourceCapabilities<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireConfigValueSource<'de> {
    pub fn as_ref(&self) -> crate::config_value_source::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::config_value_source::Ref::PackagePath(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

            2 => crate::config_value_source::Ref::Capabilities(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfigSourceCapabilities<'_>>()
            }),

            unknown => crate::config_value_source::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireConfigValueSource<'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::WireString<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireConfigSourceCapabilities<'static>,
            >(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireConfigValueSource<'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::WireString<'_>>().fmt(f) },
            2 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfigSourceCapabilities<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalConfigValueSource<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalConfigValueSource<'static> {
    type Decoded<'de> = WireOptionalConfigValueSource<'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> WireOptionalConfigValueSource<'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<&WireConfigValueSource<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireConfigValueSource<'de>> {
        if self.is_some() {
            Some(WireConfigValueSource { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigValueSource<'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::WireString<'static>>(
                raw, decoder,
            )?,

            2 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                crate::WireConfigSourceCapabilities<'static>,
            >(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalConfigValueSource<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

#[doc = " The schema of a component\'s configuration interface.\n"]
#[derive(Clone, Debug, Default)]
pub struct ConfigSchema {
    pub fields: Option<Vec<crate::ConfigField>>,

    pub checksum: Option<crate::ConfigChecksum>,

    pub value_source: Option<crate::ConfigValueSource>,
}

impl ConfigSchema {
    fn __max_ordinal(&self) -> usize {
        if self.value_source.is_some() {
            return 3;
        }

        if self.checksum.is_some() {
            return 2;
        }

        if self.fields.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigSchema {
    type Encoded = WireConfigSchema<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigSchema
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigSchema { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(value_source) = self.value_source.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value_source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(checksum) = self.checksum.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            checksum,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(fields) = self.fields.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            fields,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigSchema
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigSchema { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(value_source) = &self.value_source {
                        ::fidl_next::WireEnvelope::encode_value(
                            value_source,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(checksum) = &self.checksum {
                        ::fidl_next::WireEnvelope::encode_value(
                            checksum,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(fields) = &self.fields {
                        ::fidl_next::WireEnvelope::encode_value(
                            fields,
                            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<WireConfigSchema<'de>> for ConfigSchema {
    #[inline]
    fn from_wire(wire: WireConfigSchema<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let fields = wire.table.get(1);

        let checksum = wire.table.get(2);

        let value_source = wire.table.get(3);

        Self {


                fields: fields.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigField<'de>>>() }
                )),


                checksum: checksum.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireConfigChecksum<'de>>() }
                )),


                value_source: value_source.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireConfigValueSource<'de>>() }
                )),

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigSchema<'de>> for ConfigSchema {
    #[inline]
    fn from_wire_ref(wire: &WireConfigSchema<'de>) -> Self {
        Self {


                fields: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigField<'de>>>() }
                    )),


                checksum: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireConfigChecksum<'de>>() }
                    )),


                value_source: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireConfigValueSource<'de>>() }
                    )),

        }
    }
}

/// The wire type corresponding to [`ConfigSchema`].
#[repr(C)]
pub struct WireConfigSchema<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireConfigSchema<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigField<'de>>>()
        });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigChecksum<'de>>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<crate::WireConfigValueSource<'de>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireConfigSchema<'static> {
    type Decoded<'de> = WireConfigSchema<'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 WireConfigSchema<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireConfigField<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigChecksum<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        crate::WireConfigValueSource<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireConfigSchema<'de> {
    pub fn fields(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireConfigField<'de>>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn checksum(&self) -> Option<&crate::WireConfigChecksum<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn value_source(&self) -> Option<&crate::WireConfigValueSource<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireConfigSchema<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConfigSchema")
            .field("fields", &self.fields())
            .field("checksum", &self.checksum())
            .field("value_source", &self.value_source())
            .finish()
    }
}

#[doc = " A component declaration.\n\n This information is typically encoded in the component manifest (.cm file)\n if it has one or may be generated at runtime by a component resolver for\n those that don\'t.\n"]
#[derive(Clone, Debug, Default)]
pub struct Component {
    pub program: Option<crate::Program>,

    pub uses: Option<Vec<crate::Use>>,

    pub exposes: Option<Vec<crate::Expose>>,

    pub offers: Option<Vec<crate::Offer>>,

    pub capabilities: Option<Vec<crate::Capability>>,

    pub children: Option<Vec<crate::Child>>,

    pub collections: Option<Vec<crate::Collection>>,

    pub environments: Option<Vec<crate::Environment>>,

    pub facets: Option<::fidl_next_fuchsia_data::Dictionary>,

    pub config: Option<crate::ConfigSchema>,
}

impl Component {
    fn __max_ordinal(&self) -> usize {
        if self.config.is_some() {
            return 10;
        }

        if self.facets.is_some() {
            return 9;
        }

        if self.environments.is_some() {
            return 8;
        }

        if self.collections.is_some() {
            return 7;
        }

        if self.children.is_some() {
            return 6;
        }

        if self.capabilities.is_some() {
            return 5;
        }

        if self.offers.is_some() {
            return 4;
        }

        if self.exposes.is_some() {
            return 3;
        }

        if self.uses.is_some() {
            return 2;
        }

        if self.program.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Component {
    type Encoded = WireComponent<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Component
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireComponent { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                10 => {
                    if let Some(config) = self.config.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            config,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                9 => {
                    if let Some(facets) = self.facets.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            facets,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(environments) = self.environments.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            environments,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(collections) = self.collections.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            collections,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(children) = self.children.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            children,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(capabilities) = self.capabilities.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            capabilities,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(offers) = self.offers.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            offers,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(exposes) = self.exposes.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            exposes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(uses) = self.uses.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            uses,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(program) = self.program.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            program,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Component
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireComponent { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                10 => {
                    if let Some(config) = &self.config {
                        ::fidl_next::WireEnvelope::encode_value(
                            config,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                9 => {
                    if let Some(facets) = &self.facets {
                        ::fidl_next::WireEnvelope::encode_value(
                            facets,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(environments) = &self.environments {
                        ::fidl_next::WireEnvelope::encode_value(
                            environments,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(collections) = &self.collections {
                        ::fidl_next::WireEnvelope::encode_value(
                            collections,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(children) = &self.children {
                        ::fidl_next::WireEnvelope::encode_value(
                            children,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(capabilities) = &self.capabilities {
                        ::fidl_next::WireEnvelope::encode_value(
                            capabilities,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(offers) = &self.offers {
                        ::fidl_next::WireEnvelope::encode_value(
                            offers,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(exposes) = &self.exposes {
                        ::fidl_next::WireEnvelope::encode_value(
                            exposes,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(uses) = &self.uses {
                        ::fidl_next::WireEnvelope::encode_value(
                            uses,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(program) = &self.program {
                        ::fidl_next::WireEnvelope::encode_value(
                            program,
                            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<WireComponent<'de>> for Component {
    #[inline]
    fn from_wire(wire: WireComponent<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let program = wire.table.get(1);

        let uses = wire.table.get(2);

        let exposes = wire.table.get(3);

        let offers = wire.table.get(4);

        let capabilities = wire.table.get(5);

        let children = wire.table.get(6);

        let collections = wire.table.get(7);

        let environments = wire.table.get(8);

        let facets = wire.table.get(9);

        let config = wire.table.get(10);

        Self {


                program: program.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireProgram<'de>>() }
                )),


                uses: uses.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireUse<'de>>>() }
                )),


                exposes: exposes.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireExpose<'de>>>() }
                )),


                offers: offers.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>() }
                )),


                capabilities: capabilities.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireCapability<'de>>>() }
                )),


                children: children.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireChild<'de>>>() }
                )),


                collections: collections.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireCollection<'de>>>() }
                )),


                environments: environments.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireEnvironment<'de>>>() }
                )),


                facets: facets.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>() }
                )),


                config: config.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireConfigSchema<'de>>() }
                )),

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireComponent<'de>> for Component {
    #[inline]
    fn from_wire_ref(wire: &WireComponent<'de>) -> Self {
        Self {


                program: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireProgram<'de>>() }
                    )),


                uses: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireUse<'de>>>() }
                    )),


                exposes: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireExpose<'de>>>() }
                    )),


                offers: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>() }
                    )),


                capabilities: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireCapability<'de>>>() }
                    )),


                children: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireChild<'de>>>() }
                    )),


                collections: wire.table.get(7)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireCollection<'de>>>() }
                    )),


                environments: wire.table.get(8)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireEnvironment<'de>>>() }
                    )),


                facets: wire.table.get(9)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>() }
                    )),


                config: wire.table.get(10)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireConfigSchema<'de>>() }
                    )),

        }
    }
}

/// The wire type corresponding to [`Component`].
#[repr(C)]
pub struct WireComponent<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireComponent<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireProgram<'de>>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireUse<'de>>>()
        });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireExpose<'de>>>()
        });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>()
        });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireCapability<'de>>>()
        });

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireChild<'de>>>()
        });

        let _ = self.table.get(7).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireCollection<'de>>>()
        });

        let _ = self.table.get(8).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireEnvironment<'de>>>()
        });

        let _ = self.table.get(9).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
        });

        let _ = self
            .table
            .get(10)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigSchema<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireComponent<'static> {
    type Decoded<'de> = WireComponent<'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 WireComponent<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireProgram<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireUse<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireExpose<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireOffer<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireCapability<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireChild<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireCollection<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireEnvironment<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_data::WireDictionary<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigSchema<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireComponent<'de> {
    pub fn program(&self) -> Option<&crate::WireProgram<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn uses(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireUse<'de>>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn exposes(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireExpose<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn offers(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireOffer<'de>>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn capabilities(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireCapability<'de>>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn children(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireChild<'de>>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn collections(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireCollection<'de>>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn environments(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireEnvironment<'de>>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn facets(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary<'de>> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn config(&self) -> Option<&crate::WireConfigSchema<'de>> {
        unsafe { Some(self.table.get(10)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireComponent<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Component")
            .field("program", &self.program())
            .field("uses", &self.uses())
            .field("exposes", &self.exposes())
            .field("offers", &self.offers())
            .field("capabilities", &self.capabilities())
            .field("children", &self.children())
            .field("collections", &self.collections())
            .field("environments", &self.environments())
            .field("facets", &self.facets())
            .field("config", &self.config())
            .finish()
    }
}

#[doc = " An individual configuration value. It is matched against a specific configuration field based\n on its offset within `ValuesData.values`.\n"]
#[derive(Clone, Debug, Default)]
pub struct ConfigValueSpec {
    pub value: Option<crate::ConfigValue>,
}

impl ConfigValueSpec {
    fn __max_ordinal(&self) -> usize {
        if self.value.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigValueSpec {
    type Encoded = WireConfigValueSpec<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigValueSpec
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigValueSpec { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(value) = self.value.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigValueSpec
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigValueSpec { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(value) = &self.value {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            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<WireConfigValueSpec<'de>> for ConfigValueSpec {
    #[inline]
    fn from_wire(wire: WireConfigValueSpec<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let value = wire.table.get(1);

        Self {
            value: value.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireConfigValue<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigValueSpec<'de>> for ConfigValueSpec {
    #[inline]
    fn from_wire_ref(wire: &WireConfigValueSpec<'de>) -> Self {
        Self {
            value: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<crate::WireConfigValue<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`ConfigValueSpec`].
#[repr(C)]
pub struct WireConfigValueSpec<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireConfigValueSpec<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigValue<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireConfigValueSpec<'static> {
    type Decoded<'de> = WireConfigValueSpec<'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 WireConfigValueSpec<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigValue<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireConfigValueSpec<'de> {
    pub fn value(&self) -> Option<&crate::WireConfigValue<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireConfigValueSpec<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConfigValueSpec").field("value", &self.value()).finish()
    }
}

#[doc = " Contents of the configuration value file. Defines the base values for a component\'s config.\n"]
#[derive(Clone, Debug, Default)]
pub struct ConfigValuesData {
    pub values: Option<Vec<crate::ConfigValueSpec>>,

    pub checksum: Option<crate::ConfigChecksum>,
}

impl ConfigValuesData {
    fn __max_ordinal(&self) -> usize {
        if self.checksum.is_some() {
            return 2;
        }

        if self.values.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigValuesData {
    type Encoded = WireConfigValuesData<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigValuesData
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigValuesData { 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(checksum) = self.checksum.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            checksum,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(values) = self.values.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            values,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ConfigValuesData
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigValuesData { 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(checksum) = &self.checksum {
                        ::fidl_next::WireEnvelope::encode_value(
                            checksum,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(values) = &self.values {
                        ::fidl_next::WireEnvelope::encode_value(
                            values,
                            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<WireConfigValuesData<'de>> for ConfigValuesData {
    #[inline]
    fn from_wire(wire: WireConfigValuesData<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let values = wire.table.get(1);

        let checksum = wire.table.get(2);

        Self {


                values: values.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigValueSpec<'de>>>() }
                )),


                checksum: checksum.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireConfigChecksum<'de>>() }
                )),

        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireConfigValuesData<'de>> for ConfigValuesData {
    #[inline]
    fn from_wire_ref(wire: &WireConfigValuesData<'de>) -> Self {
        Self {


                values: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigValueSpec<'de>>>() }
                    )),


                checksum: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::WireConfigChecksum<'de>>() }
                    )),

        }
    }
}

/// The wire type corresponding to [`ConfigValuesData`].
#[repr(C)]
pub struct WireConfigValuesData<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireConfigValuesData<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireConfigValueSpec<'de>>>()
                });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireConfigChecksum<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireConfigValuesData<'static> {
    type Decoded<'de> = WireConfigValuesData<'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 WireConfigValuesData<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireConfigValueSpec<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigChecksum<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireConfigValuesData<'de> {
    pub fn values(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireConfigValueSpec<'de>>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn checksum(&self) -> Option<&crate::WireConfigChecksum<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireConfigValuesData<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ConfigValuesData")
            .field("values", &self.values())
            .field("checksum", &self.checksum())
            .finish()
    }
}

#[doc = " Indicates the event name to subscribe to with a given event mode.\n"]
#[derive(Clone, Debug, Default)]
pub struct EventSubscription {
    pub event_name: Option<String>,
}

impl EventSubscription {
    fn __max_ordinal(&self) -> usize {
        if self.event_name.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for EventSubscription {
    type Encoded = WireEventSubscription<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for EventSubscription
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireEventSubscription { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(event_name) = self.event_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            event_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for EventSubscription
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireEventSubscription { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(event_name) = &self.event_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            event_name,
                            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<WireEventSubscription<'de>> for EventSubscription {
    #[inline]
    fn from_wire(wire: WireEventSubscription<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let event_name = wire.table.get(1);

        Self {
            event_name: event_name.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireEventSubscription<'de>> for EventSubscription {
    #[inline]
    fn from_wire_ref(wire: &WireEventSubscription<'de>) -> Self {
        Self {
            event_name: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`EventSubscription`].
#[repr(C)]
pub struct WireEventSubscription<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireEventSubscription<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireEventSubscription<'static> {
    type Decoded<'de> = WireEventSubscription<'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 WireEventSubscription<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let event_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if event_name.len() > 100 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: event_name.len() as u64,
                            limit: 100,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireEventSubscription<'de> {
    pub fn event_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireEventSubscription<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("EventSubscription").field("event_name", &self.event_name()).finish()
    }
}

#[derive(Clone, Debug)]
pub enum LayoutParameter {
    NestedType(crate::ConfigType),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for LayoutParameter {
    type Encoded = WireLayoutParameter<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for LayoutParameter
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 WireLayoutParameter { raw, _phantom: _ } = out);

        match self {
            Self::NestedType(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ConfigType,
            >(value, 1, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LayoutParameter
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 WireLayoutParameter { raw, _phantom: _ } = out);

        match self {
            Self::NestedType(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &crate::ConfigType,
            >(value, 1, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for LayoutParameter {
    type EncodedOption = WireOptionalLayoutParameter<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LayoutParameter
where
    ___E: ?Sized,
    LayoutParameter: ::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 WireOptionalLayoutParameter { 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 LayoutParameter
where
    ___E: ?Sized,
    LayoutParameter: ::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 WireOptionalLayoutParameter { 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<WireLayoutParameter<'de>> for LayoutParameter {
    #[inline]
    fn from_wire(wire: WireLayoutParameter<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::NestedType(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<crate::WireConfigType<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireLayoutParameter<'de>> for LayoutParameter {
    #[inline]
    fn from_wire_ref(wire: &WireLayoutParameter<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::NestedType(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw.get().deref_unchecked::<crate::WireConfigType<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalLayoutParameter<'de>> for Box<LayoutParameter> {
    #[inline]
    fn from_wire_option(wire: WireOptionalLayoutParameter<'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<WireOptionalLayoutParameter<'de>>
    for Box<LayoutParameter>
{
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalLayoutParameter<'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 [`LayoutParameter`].
#[repr(transparent)]
pub struct WireLayoutParameter<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireLayoutParameter<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireConfigType<'de>>() };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireLayoutParameter<'static> {
    type Decoded<'de> = WireLayoutParameter<'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 layout_parameter {
    pub enum Ref<'de> {
        NestedType(&'de crate::WireConfigType<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireLayoutParameter<'de> {
    pub fn as_ref(&self) -> crate::layout_parameter::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::layout_parameter::Ref::NestedType(unsafe {
                self.raw.get().deref_unchecked::<crate::WireConfigType<'_>>()
            }),

            unknown => crate::layout_parameter::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLayoutParameter<'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, crate::WireConfigType<'static>>(
                raw, decoder,
            )?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireLayoutParameter<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireConfigType<'_>>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalLayoutParameter<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalLayoutParameter<'static> {
    type Decoded<'de> = WireOptionalLayoutParameter<'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> WireOptionalLayoutParameter<'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<&WireLayoutParameter<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireLayoutParameter<'de>> {
        if self.is_some() {
            Some(WireLayoutParameter { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalLayoutParameter<'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, crate::WireConfigType<'static>>(
                raw, decoder,
            )?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalLayoutParameter<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

pub const MAX_MONIKER_LENGTH: u32 = 4096;

#[doc = " The maximum number of EventSubscriptions in an EventStream.\n"]
pub const MAX_NUM_EVENT_STREAM_SUBSCRIPTIONS: u64 = 100;

#[derive(Clone, Debug)]
pub struct ResolvedConfigField {
    pub key: String,

    pub value: crate::ConfigValue,
}

impl ::fidl_next::Encodable for ResolvedConfigField {
    type Encoded = WireResolvedConfigField<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolvedConfigField
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 ResolvedConfigField
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 ResolvedConfigField {
    type EncodedOption = ::fidl_next::WireBox<'static, WireResolvedConfigField<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolvedConfigField
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfigField: ::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 ResolvedConfigField
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfigField: ::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<WireResolvedConfigField<'de>> for ResolvedConfigField {
    #[inline]
    fn from_wire(wire: WireResolvedConfigField<'de>) -> Self {
        Self {
            key: ::fidl_next::FromWire::from_wire(wire.key),

            value: ::fidl_next::FromWire::from_wire(wire.value),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireResolvedConfigField<'de>> for ResolvedConfigField {
    #[inline]
    fn from_wire_ref(wire: &WireResolvedConfigField<'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 [`ResolvedConfigField`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolvedConfigField<'de> {
    pub key: ::fidl_next::WireString<'de>,

    pub value: crate::WireConfigValue<'de>,
}

unsafe impl ::fidl_next::Wire for WireResolvedConfigField<'static> {
    type Decoded<'de> = WireResolvedConfigField<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolvedConfigField<'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)?;

        ::fidl_next::Decode::decode(value.as_mut(), decoder)?;

        Ok(())
    }
}

#[doc = " A configuration that has been completely resolved by component manager.\n"]
#[derive(Clone, Debug)]
pub struct ResolvedConfig {
    pub fields: Vec<crate::ResolvedConfigField>,

    pub checksum: crate::ConfigChecksum,
}

impl ::fidl_next::Encodable for ResolvedConfig {
    type Encoded = WireResolvedConfig<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolvedConfig
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 {
                fields,
                checksum,

            } = out;
        }

        ::fidl_next::Encode::encode(self.fields, encoder, fields)?;

        ::fidl_next::Encode::encode(self.checksum, encoder, checksum)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ResolvedConfig
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 {
                fields,
                checksum,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.fields, encoder, fields)?;

        ::fidl_next::EncodeRef::encode_ref(&self.checksum, encoder, checksum)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for ResolvedConfig {
    type EncodedOption = ::fidl_next::WireBox<'static, WireResolvedConfig<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolvedConfig
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfig: ::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 ResolvedConfig
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfig: ::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<WireResolvedConfig<'de>> for ResolvedConfig {
    #[inline]
    fn from_wire(wire: WireResolvedConfig<'de>) -> Self {
        Self {
            fields: ::fidl_next::FromWire::from_wire(wire.fields),

            checksum: ::fidl_next::FromWire::from_wire(wire.checksum),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireResolvedConfig<'de>> for ResolvedConfig {
    #[inline]
    fn from_wire_ref(wire: &WireResolvedConfig<'de>) -> Self {
        Self {
            fields: ::fidl_next::FromWireRef::from_wire_ref(&wire.fields),

            checksum: ::fidl_next::FromWireRef::from_wire_ref(&wire.checksum),
        }
    }
}

/// The wire type corresponding to [`ResolvedConfig`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolvedConfig<'de> {
    pub fields: ::fidl_next::WireVector<'de, crate::WireResolvedConfigField<'de>>,

    pub checksum: crate::WireConfigChecksum<'de>,
}

unsafe impl ::fidl_next::Wire for WireResolvedConfig<'static> {
    type Decoded<'de> = WireResolvedConfig<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolvedConfig<'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 fields,
                mut checksum,

            } = slot;
        }

        ::fidl_next::Decode::decode(fields.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(checksum.as_mut(), decoder)?;

        Ok(())
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::core::convert::From<crate::AllowedOffers> for ::fidl_fuchsia_component_decl::AllowedOffers {
        #[inline]
        fn from(from: crate::AllowedOffers) -> Self {
            match crate::AllowedOffers::from(from) {
                crate::AllowedOffers::StaticOnly => Self::StaticOnly,

                crate::AllowedOffers::StaticAndDynamic => Self::StaticAndDynamic,
            }
        }
    }

    impl ::core::convert::From<crate::Availability> for ::fidl_fuchsia_component_decl::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::StorageId> for ::fidl_fuchsia_component_decl::StorageId {
        #[inline]
        fn from(from: crate::StorageId) -> Self {
            match crate::StorageId::from(from) {
                crate::StorageId::StaticInstanceId => Self::StaticInstanceId,

                crate::StorageId::StaticInstanceIdOrMoniker => Self::StaticInstanceIdOrMoniker,
            }
        }
    }

    impl ::core::convert::From<crate::DeliveryType> for ::fidl_fuchsia_component_decl::DeliveryType {
        #[inline]
        fn from(from: crate::DeliveryType) -> Self {
            match crate::DeliveryType::from(from) {
                crate::DeliveryType::Immediate => Self::Immediate,

                crate::DeliveryType::OnReadable => Self::OnReadable,

                crate::DeliveryType::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::core::convert::From<crate::StartupMode> for ::fidl_fuchsia_component_decl::StartupMode {
        #[inline]
        fn from(from: crate::StartupMode) -> Self {
            match crate::StartupMode::from(from) {
                crate::StartupMode::Lazy => Self::Lazy,

                crate::StartupMode::Eager => Self::Eager,
            }
        }
    }

    impl ::core::convert::From<crate::OnTerminate> for ::fidl_fuchsia_component_decl::OnTerminate {
        #[inline]
        fn from(from: crate::OnTerminate) -> Self {
            match crate::OnTerminate::from(from) {
                crate::OnTerminate::None => Self::None,

                crate::OnTerminate::Reboot => Self::Reboot,
            }
        }
    }

    impl ::core::convert::From<crate::Durability> for ::fidl_fuchsia_component_decl::Durability {
        #[inline]
        fn from(from: crate::Durability) -> Self {
            match crate::Durability::from(from) {
                crate::Durability::Transient => Self::Transient,

                crate::Durability::SingleRun => Self::SingleRun,
            }
        }
    }

    impl ::core::convert::From<crate::DependencyType>
        for ::fidl_fuchsia_component_decl::DependencyType
    {
        #[inline]
        fn from(from: crate::DependencyType) -> Self {
            match crate::DependencyType::from(from) {
                crate::DependencyType::Strong => Self::Strong,

                crate::DependencyType::Weak => Self::Weak,
            }
        }
    }

    impl ::core::convert::From<crate::EnvironmentExtends>
        for ::fidl_fuchsia_component_decl::EnvironmentExtends
    {
        #[inline]
        fn from(from: crate::EnvironmentExtends) -> Self {
            match crate::EnvironmentExtends::from(from) {
                crate::EnvironmentExtends::None => Self::None,

                crate::EnvironmentExtends::Realm => Self::Realm,
            }
        }
    }

    impl ::core::convert::From<crate::ConfigTypeLayout>
        for ::fidl_fuchsia_component_decl::ConfigTypeLayout
    {
        #[inline]
        fn from(from: crate::ConfigTypeLayout) -> Self {
            match crate::ConfigTypeLayout::from(from) {
                crate::ConfigTypeLayout::Bool => Self::Bool,

                crate::ConfigTypeLayout::Uint8 => Self::Uint8,

                crate::ConfigTypeLayout::Uint16 => Self::Uint16,

                crate::ConfigTypeLayout::Uint32 => Self::Uint32,

                crate::ConfigTypeLayout::Uint64 => Self::Uint64,

                crate::ConfigTypeLayout::Int8 => Self::Int8,

                crate::ConfigTypeLayout::Int16 => Self::Int16,

                crate::ConfigTypeLayout::Int32 => Self::Int32,

                crate::ConfigTypeLayout::Int64 => Self::Int64,

                crate::ConfigTypeLayout::String => Self::String,

                crate::ConfigTypeLayout::Vector => Self::Vector,

                crate::ConfigTypeLayout::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::core::convert::From<crate::ConfigMutability>
        for ::fidl_fuchsia_component_decl::ConfigMutability
    {
        #[inline]
        fn from(from: crate::ConfigMutability) -> Self {
            Self::from_bits_retain(from.bits())
        }
    }
}