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

unsafe impl<___E> ::fidl_next::Encode<___E> for AllowedOffers
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireAllowedOffers> for AllowedOffers {
    #[inline]
    fn take_from(from: &WireAllowedOffers) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireAllowedOffers {
    #[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;
}

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

            Self::Optional => 2,

            Self::SameAsTarget => 3,

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

        Ok(())
    }
}

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

            2 => Self::Optional,

            3 => Self::SameAsTarget,

            4 => Self::Transitional,

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

            Availability::Optional => WireAvailability::OPTIONAL,

            Availability::SameAsTarget => WireAvailability::SAME_AS_TARGET,

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

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

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)]
pub struct Service {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Service {
    type Encoded = WireService;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(source_path) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireService> for Service {
    #[inline]
    fn take_from(from: &WireService) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireService {
    #[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
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>(
                        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>(
                        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 WireService {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

impl ::core::fmt::Debug for WireService {
    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)]
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.name.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for Directory {
    type Encoded = WireDirectory;
}

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(rights) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireDirectory> for Directory {
    #[inline]
    fn take_from(from: &WireDirectory) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireDirectory {
    #[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
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>(
                        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>(
                        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 WireDirectory {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_path(&self) -> Option<&::fidl_next::WireString> {
        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 ::core::fmt::Debug for WireDirectory {
    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> =
        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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ParentRef> {
    type EncodedOption = ::fidl_next::WireBox<WireParentRef>;
}

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

        Ok(())
    }
}

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

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

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

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

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<SelfRef> {
    type EncodedOption = ::fidl_next::WireBox<WireSelfRef>;
}

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for 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 = ::fidl_next::WireString;

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

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

    pub collection: ::fidl_next::WireOptionalString,
}

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

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

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCollectionRef
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> =
        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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<FrameworkRef> {
    type EncodedOption = ::fidl_next::WireBox<WireFrameworkRef>;
}

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for 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;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityRef
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> =
        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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DebugRef> {
    type EncodedOption = ::fidl_next::WireBox<WireDebugRef>;
}

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

        Ok(())
    }
}

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

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

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

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

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<VoidRef> {
    type EncodedOption = ::fidl_next::WireBox<WireVoidRef>;
}

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for 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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for StorageId
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireStorageId> for StorageId {
    #[inline]
    fn take_from(from: &WireStorageId) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireStorageId {
    #[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)]
pub struct Runner {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Runner {
    type Encoded = WireRunner;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(source_path) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireRunner> for Runner {
    #[inline]
    fn take_from(from: &WireRunner) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireRunner {
    #[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
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>(
                        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>(
                        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 WireRunner {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

impl ::core::fmt::Debug for WireRunner {
    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)]
pub struct Resolver {
    pub name: Option<String>,

    pub source_path: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Resolver {
    type Encoded = WireResolver;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(source_path) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireResolver> for Resolver {
    #[inline]
    fn take_from(from: &WireResolver) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireResolver {
    #[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
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>(
                        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>(
                        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 WireResolver {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

impl ::core::fmt::Debug for WireResolver {
    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)]
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;
}

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

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

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(name) = &mut 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 ::fidl_next::TakeFrom<WireEventStream> for EventStream {
    #[inline]
    fn take_from(from: &WireEventStream) -> Self {
        Self { name: from.name().map(::fidl_next::TakeFrom::take_from) }
    }
}

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

unsafe impl ::fidl_next::ZeroPadding for WireEventStream {
    #[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
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>(
                        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 WireEventStream {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireEventStream {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

            7 => Self::Int16(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireI16>()
            })),

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

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

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

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

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

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

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

pub mod config_single_value {
    pub enum Ref<'union> {
        Bool(&'union bool),

        Uint8(&'union u8),

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

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

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

        Int8(&'union i8),

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

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

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

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

        UnknownOrdinal_(u64),
    }
}

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireConfigSingleValue {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConfigSingleValue {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

            6 => Self::Int8Vector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireVector<i8>>()
            })),

            7 => Self::Int16Vector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireVector<::fidl_next::WireI16>>()
            })),

            8 => Self::Int32Vector(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireVector<::fidl_next::WireI32>>()
            })),

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

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

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

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

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

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

pub mod config_vector_value {
    pub enum Ref<'union> {
        BoolVector(&'union ::fidl_next::WireVector<bool>),

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

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

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

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

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

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

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

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

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

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireConfigVectorValue {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConfigVectorValue {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

pub mod config_value {
    pub enum Ref<'union> {
        Single(&'union crate::WireConfigSingleValue),

        Vector(&'union crate::WireConfigVectorValue),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireConfigValue {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConfigValue {
    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)]
pub struct Configuration {
    pub name: Option<String>,

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Configuration {
    type Encoded = WireConfiguration;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(value) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireConfiguration> for Configuration {
    #[inline]
    fn take_from(from: &WireConfiguration) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireConfiguration {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

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

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

impl ::core::fmt::Debug for WireConfiguration {
    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 = ::fidl_next::WireString;

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

unsafe impl<___E> ::fidl_next::Encode<___E> for DeliveryType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireDeliveryType> for DeliveryType {
    #[inline]
    fn take_from(from: &WireDeliveryType) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireDeliveryType {
    #[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)]
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.name.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for Protocol {
    type Encoded = WireProtocol;
}

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(delivery) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireProtocol> for Protocol {
    #[inline]
    fn take_from(from: &WireProtocol) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireProtocol {
    #[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
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>(
                        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>(
                        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 WireProtocol {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

impl ::core::fmt::Debug for WireProtocol {
    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> =
        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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

            } = out;
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<EnvironmentRef> {
    type EncodedOption = ::fidl_next::WireBox<WireEnvironmentRef>;
}

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for 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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

            7 => Self::Debug(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDebugRef>()
            })),

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

            9 => Self::Environment(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireEnvironmentRef>()
            })),

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

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

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

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

pub mod ref_ {
    pub enum Ref<'union> {
        Parent(&'union crate::WireParentRef),

        Self_(&'union crate::WireSelfRef),

        Child(&'union crate::WireChildRef),

        Collection(&'union crate::WireCollectionRef),

        Framework(&'union crate::WireFrameworkRef),

        Capability(&'union crate::WireCapabilityRef),

        Debug(&'union crate::WireDebugRef),

        VoidType(&'union crate::WireVoidRef),

        Environment(&'union crate::WireEnvironmentRef),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireCapabilityRef>(
                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 ::core::fmt::Debug for WireRef {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

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

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

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireCapabilityRef>(
                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 ::core::fmt::Debug for WireOptionalRef {
    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)]
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.name.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Storage {
    type Encoded = WireStorage;
}

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

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

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(storage_id) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireStorage> for Storage {
    #[inline]
    fn take_from(from: &WireStorage) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireStorage {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireStorage {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn backing_dir(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn subdir(&self) -> Option<&::fidl_next::WireString> {
        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 ::core::fmt::Debug for WireStorage {
    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)]
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.name.is_some() {
            return 1;
        }

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Dictionary {
    type Encoded = WireDictionary;
}

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

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

        for i in 1..=max_ord {
            match i {
                4 => {
                    if let Some(source_path) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireDictionary> for Dictionary {
    #[inline]
    fn take_from(from: &WireDictionary) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireDictionary {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireDictionary {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

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

impl ::core::fmt::Debug for WireDictionary {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

            10 => Self::Config(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireConfiguration>()
            })),

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

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

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

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

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

        Protocol(&'union crate::WireProtocol),

        Directory(&'union crate::WireDirectory),

        Storage(&'union crate::WireStorage),

        Runner(&'union crate::WireRunner),

        Resolver(&'union crate::WireResolver),

        EventStream(&'union crate::WireEventStream),

        Dictionary(&'union crate::WireDictionary),

        Config(&'union crate::WireConfiguration),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

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

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfiguration>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireCapability {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<crate::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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfiguration>(
                raw, decoder,
            )?,

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

        Ok(())
    }
}

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

#[doc = " 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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for StartupMode
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireStartupMode> for StartupMode {
    #[inline]
    fn take_from(from: &WireStartupMode) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireStartupMode {
    #[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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for OnTerminate
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireOnTerminate> for OnTerminate {
    #[inline]
    fn take_from(from: &WireOnTerminate) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireOnTerminate {
    #[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 = ::fidl_next::WireString;

#[doc = " A directive to override the value of a particular configuration field in the child.\n"]
#[derive(Clone, Debug)]
pub struct ConfigOverride {
    pub key: Option<String>,

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ConfigOverride {
    type Encoded = WireConfigOverride;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(value) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireConfigOverride> for ConfigOverride {
    #[inline]
    fn take_from(from: &WireConfigOverride) -> Self {
        Self {
            key: from.key().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireConfigOverride {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

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

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

impl ::core::fmt::Debug for WireConfigOverride {
    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)]
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.name.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Child {
    type Encoded = WireChild;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(config_overrides) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireChild> for Child {
    #[inline]
    fn take_from(from: &WireChild) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireChild {
    #[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
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>(
                        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>(
                        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>(
                        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<crate::WireConfigOverride>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

    pub fn url(&self) -> Option<&::fidl_next::WireString> {
        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> {
        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<crate::WireConfigOverride>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireChild {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Durability
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireDurability> for Durability {
    #[inline]
    fn take_from(from: &WireDurability) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireDurability {
    #[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)]
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.name.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Collection {
    type Encoded = WireCollection;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(persistent_storage) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireCollection> for Collection {
    #[inline]
    fn take_from(from: &WireCollection) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireCollection {
    #[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
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>(
                        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>(
                        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 WireCollection {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        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 ::core::fmt::Debug for WireCollection {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DependencyType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireDependencyType> for DependencyType {
    #[inline]
    fn take_from(from: &WireDependencyType) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireDependencyType {
    #[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;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NameMapping> {
    type EncodedOption = ::fidl_next::WireBox<WireNameMapping>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNameMapping> for NameMapping {
    #[inline]
    fn take_from(from: &WireNameMapping) -> Self {
        Self {
            source_name: ::fidl_next::TakeFrom::take_from(&from.source_name),

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

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

    pub target_name: ::fidl_next::WireString,
}

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

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

unsafe impl<___E> ::fidl_next::Encode<___E> for EnvironmentExtends
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireEnvironmentExtends> for EnvironmentExtends {
    #[inline]
    fn take_from(from: &WireEnvironmentExtends) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireEnvironmentExtends {
    #[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 = ::fidl_next::WireString;

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

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigTypeLayout
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        _: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let 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::TakeFrom<WireConfigTypeLayout> for ConfigTypeLayout {
    #[inline]
    fn take_from(from: &WireConfigTypeLayout) -> Self {
        Self::from(*from)
    }
}

/// 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::ZeroPadding for WireConfigTypeLayout {
    #[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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireLayoutConstraint { raw } = 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 Box<LayoutConstraint> {
    type EncodedOption = WireOptionalLayoutConstraint;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLayoutConstraint> for LayoutConstraint {
    #[inline]
    fn take_from(from: &WireLayoutConstraint) -> Self {
        match from.raw.ordinal() {
            1 => Self::MaxSize(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            })),

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

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

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

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

pub mod layout_constraint {
    pub enum Ref<'union> {
        MaxSize(&'union ::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_unchecked::<::fidl_next::WireU32>() } },

            _ => Self { raw: unsafe { self.raw.clone_unchecked::<()>() } },
        }
    }
}

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 } = 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,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalLayoutConstraint {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = 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
        }
    }
}

impl Clone for WireOptionalLayoutConstraint {
    fn clone(&self) -> Self {
        if self.is_none() {
            return WireOptionalLayoutConstraint { raw: ::fidl_next::RawWireUnion::absent() };
        }

        match self.raw.ordinal() {
            1 => Self { raw: unsafe { self.raw.clone_unchecked::<::fidl_next::WireU32>() } },

            _ => Self { raw: unsafe { self.raw.clone_unchecked::<()>() } },
        }
    }
}

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 } = 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;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ConfigType> {
    type EncodedOption = ::fidl_next::WireBox<WireConfigType>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConfigType> for ConfigType {
    #[inline]
    fn take_from(from: &WireConfigType) -> Self {
        Self {
            layout: ::fidl_next::TakeFrom::take_from(&from.layout),

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

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

/// The wire type corresponding to [`ConfigType`].
#[derive(Debug)]
#[repr(C)]
pub struct WireConfigType {
    pub layout: crate::WireConfigTypeLayout,

    pub parameters: ::fidl_next::WireOptionalVector<crate::WireLayoutParameter>,

    pub constraints: ::fidl_next::WireVector<crate::WireLayoutConstraint>,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigType {
    #[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
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;
}

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConfigChecksum> for ConfigChecksum {
    #[inline]
    fn take_from(from: &WireConfigChecksum) -> Self {
        match from.raw.ordinal() {
            1 => Self::Sha256(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<[u8; 32]>()
            })),

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

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

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

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

pub mod config_checksum {
    pub enum Ref<'union> {
        Sha256(&'union [u8; 32]),

        UnknownOrdinal_(u64),
    }
}

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireConfigChecksum {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConfigChecksum {
    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)]
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.source_name.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseStorage {
    type Encoded = WireUseStorage;
}

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(availability) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseStorage> for UseStorage {
    #[inline]
    fn take_from(from: &WireUseStorage) -> Self {
        Self {
            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseStorage {
    #[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
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>(
                        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>(
                        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 WireUseStorage {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

impl ::core::fmt::Debug for WireUseStorage {
    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(
        &mut 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::TakeFrom<WireConfigMutability> for ConfigMutability {
    #[inline]
    fn take_from(from: &WireConfigMutability) -> Self {
        Self::from(*from)
    }
}

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

unsafe impl ::fidl_next::ZeroPadding for WireConfigMutability {
    #[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)]
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.key.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for ConfigField {
    type Encoded = WireConfigField;
}

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(mutability) = &mut 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_) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireConfigField> for ConfigField {
    #[inline]
    fn take_from(from: &WireConfigField) -> Self {
        Self {
            key: from.key().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireConfigField {
    #[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
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>(
                        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>(
                        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 WireConfigField {
    pub fn key(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

impl ::core::fmt::Debug for WireConfigField {
    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)]
pub struct Program {
    pub runner: Option<String>,

    pub info: Option<::fidl_next_fuchsia_data::Dictionary>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Program {
    type Encoded = WireProgram;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(info) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireProgram> for Program {
    #[inline]
    fn take_from(from: &WireProgram) -> Self {
        Self {
            runner: from.runner().map(::fidl_next::TakeFrom::take_from),

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

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

unsafe impl ::fidl_next::ZeroPadding for WireProgram {
    #[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
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>(
                        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,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

    pub fn info(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireProgram {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseService {
    type Encoded = WireUseService;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseService> for UseService {
    #[inline]
    fn take_from(from: &WireUseService) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseService {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        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 WireUseService {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn target_path(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseService {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseProtocol {
    type Encoded = WireUseProtocol;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseProtocol> for UseProtocol {
    #[inline]
    fn take_from(from: &WireUseProtocol) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseProtocol {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        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 WireUseProtocol {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn target_path(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseProtocol {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseDirectory {
    type Encoded = WireUseDirectory;
}

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

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

        for i in 1..=max_ord {
            match i {
                8 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseDirectory> for UseDirectory {
    #[inline]
    fn take_from(from: &WireUseDirectory) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseDirectory {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        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>(
                        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 WireUseDirectory {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn target_path(&self) -> Option<&::fidl_next::WireString> {
        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> {
        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> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseDirectory {
    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)]
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.source_name.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseEventStream {
    type Encoded = WireUseEventStream;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(filter) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseEventStream> for UseEventStream {
    #[inline]
    fn take_from(from: &WireUseEventStream) -> Self {
        Self {
            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseEventStream {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

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

    pub fn scope(&self) -> Option<&::fidl_next::WireVector<crate::WireRef>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_path(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseEventStream {
    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)]
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.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseRunner {
    type Encoded = WireUseRunner;
}

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseRunner> for UseRunner {
    #[inline]
    fn take_from(from: &WireUseRunner) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseRunner {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireUseRunner {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseRunner {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for UseConfiguration {
    type Encoded = WireUseConfiguration;
}

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

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

        for i in 1..=max_ord {
            match i {
                7 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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_) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireUseConfiguration> for UseConfiguration {
    #[inline]
    fn take_from(from: &WireUseConfiguration) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireUseConfiguration {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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 WireUseConfiguration {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn default(&self) -> Option<&crate::WireConfigValue> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireUseConfiguration {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

            7 => Self::EventStream(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireUseEventStream>()
            })),

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

            9 => Self::Config(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireUseConfiguration>()
            })),

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

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

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

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

pub mod use_ {
    pub enum Ref<'union> {
        Service(&'union crate::WireUseService),

        Protocol(&'union crate::WireUseProtocol),

        Directory(&'union crate::WireUseDirectory),

        Storage(&'union crate::WireUseStorage),

        EventStream(&'union crate::WireUseEventStream),

        Runner(&'union crate::WireUseRunner),

        Config(&'union crate::WireUseConfiguration),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireUse {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalUse {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeService {
    type Encoded = WireExposeService;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeService> for ExposeService {
    #[inline]
    fn take_from(from: &WireExposeService) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeService {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeService {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeService {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeProtocol {
    type Encoded = WireExposeProtocol;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeProtocol> for ExposeProtocol {
    #[inline]
    fn take_from(from: &WireExposeProtocol) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeProtocol {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeProtocol {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeProtocol {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeDirectory {
    type Encoded = WireExposeDirectory;
}

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

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

        for i in 1..=max_ord {
            match i {
                8 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeDirectory> for ExposeDirectory {
    #[inline]
    fn take_from(from: &WireExposeDirectory) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeDirectory {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        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 WireExposeDirectory {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        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> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeDirectory {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeRunner {
    type Encoded = WireExposeRunner;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeRunner> for ExposeRunner {
    #[inline]
    fn take_from(from: &WireExposeRunner) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeRunner {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeRunner {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeRunner {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeResolver {
    type Encoded = WireExposeResolver;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeResolver> for ExposeResolver {
    #[inline]
    fn take_from(from: &WireExposeResolver) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeResolver {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeResolver {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeResolver {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeDictionary {
    type Encoded = WireExposeDictionary;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeDictionary> for ExposeDictionary {
    #[inline]
    fn take_from(from: &WireExposeDictionary) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeDictionary {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeDictionary {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeDictionary {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ExposeConfiguration {
    type Encoded = WireExposeConfiguration;
}

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

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

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireExposeConfiguration> for ExposeConfiguration {
    #[inline]
    fn take_from(from: &WireExposeConfiguration) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireExposeConfiguration {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireExposeConfiguration {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireExposeConfiguration {
    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;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

pub mod expose {
    pub enum Ref<'union> {
        Service(&'union crate::WireExposeService),

        Protocol(&'union crate::WireExposeProtocol),

        Directory(&'union crate::WireExposeDirectory),

        Runner(&'union crate::WireExposeRunner),

        Resolver(&'union crate::WireExposeResolver),

        Dictionary(&'union crate::WireExposeDictionary),

        Config(&'union crate::WireExposeConfiguration),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireExpose {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalExpose {
    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)]
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.source.is_some() {
            return 1;
        }

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

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

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferService {
    type Encoded = WireOfferService;
}

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

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

        for i in 1..=max_ord {
            match i {
                9 => {
                    if let Some(dependency_type) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferService> for OfferService {
    #[inline]
    fn take_from(from: &WireOfferService) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferService {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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<::fidl_next::WireString>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireNameMapping>,
                    >(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>(
                        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 WireOfferService {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_instance_filter(
        &self,
    ) -> Option<&::fidl_next::WireVector<::fidl_next::WireString>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn renamed_instances(&self) -> Option<&::fidl_next::WireVector<crate::WireNameMapping>> {
        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> {
        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 ::core::fmt::Debug for WireOfferService {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferProtocol {
    type Encoded = WireOfferProtocol;
}

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

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

        for i in 1..=max_ord {
            match i {
                7 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferProtocol> for OfferProtocol {
    #[inline]
    fn take_from(from: &WireOfferProtocol) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferProtocol {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireOfferProtocol {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferProtocol {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferDirectory {
    type Encoded = WireOfferDirectory;
}

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

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

        for i in 1..=max_ord {
            match i {
                9 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferDirectory> for OfferDirectory {
    #[inline]
    fn take_from(from: &WireOfferDirectory) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferDirectory {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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>(
                        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 WireOfferDirectory {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        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> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferDirectory {
    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)]
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.source_name.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferStorage {
    type Encoded = WireOfferStorage;
}

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

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

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(availability) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferStorage> for OfferStorage {
    #[inline]
    fn take_from(from: &WireOfferStorage) -> Self {
        Self {
            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferStorage {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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 WireOfferStorage {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferStorage {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferRunner {
    type Encoded = WireOfferRunner;
}

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

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

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferRunner> for OfferRunner {
    #[inline]
    fn take_from(from: &WireOfferRunner) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferRunner {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireOfferRunner {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferRunner {
    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)]
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.is_some() {
            return 1;
        }

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferResolver {
    type Encoded = WireOfferResolver;
}

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

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

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferResolver> for OfferResolver {
    #[inline]
    fn take_from(from: &WireOfferResolver) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferResolver {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireOfferResolver {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn source_dictionary(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferResolver {
    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)]
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.source.is_some() {
            return 1;
        }

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for OfferEventStream {
    type Encoded = WireOfferEventStream;
}

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

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

        for i in 1..=max_ord {
            match i {
                7 => {
                    if let Some(availability) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferEventStream> for OfferEventStream {
    #[inline]
    fn take_from(from: &WireOfferEventStream) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireOfferEventStream {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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<crate::WireRef>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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 WireOfferEventStream {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn scope(&self) -> Option<&::fidl_next::WireVector<crate::WireRef>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn availability(&self) -> Option<&crate::WireAvailability> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferEventStream {
    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)]
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.is_some() {
            return 1;
        }

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

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

        if self.target_name.is_some() {
            return 4;
        }

        if self.dependency_type.is_some() {
            return 5;
        }

        if self.availability.is_some() {
            return 6;
        }

        if self.source_dictionary.is_some() {
            return 7;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferDictionary {
    type Encoded = WireOfferDictionary;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                7 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferDictionary> for OfferDictionary {
    #[inline]
    fn take_from(from: &WireOfferDictionary) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

            target: from.target().map(::fidl_next::TakeFrom::take_from),

            target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

            dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

            availability: from.availability().map(::fidl_next::TakeFrom::take_from),

            source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`OfferDictionary`].
#[repr(C)]
pub struct WireOfferDictionary {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireOfferDictionary {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireOfferDictionary {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferDictionary {
    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)]
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.is_some() {
            return 1;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.target.is_some() {
            return 3;
        }

        if self.target_name.is_some() {
            return 4;
        }

        if self.availability.is_some() {
            return 5;
        }

        if self.source_dictionary.is_some() {
            return 6;
        }

        0
    }
}

impl ::fidl_next::Encodable for OfferConfiguration {
    type Encoded = WireOfferConfiguration;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(source_dictionary) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireOfferConfiguration> for OfferConfiguration {
    #[inline]
    fn take_from(from: &WireOfferConfiguration) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

            target: from.target().map(::fidl_next::TakeFrom::take_from),

            target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

            availability: from.availability().map(::fidl_next::TakeFrom::take_from),

            source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`OfferConfiguration`].
#[repr(C)]
pub struct WireOfferConfiguration {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireOfferConfiguration {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireOfferConfiguration {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireOfferConfiguration {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Offer
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOffer { raw } = 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 Box<Offer> {
    type EncodedOption = WireOptionalOffer;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<Offer>
where
    ___E: ?Sized,
    Offer: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalOffer { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireOffer> for Offer {
    #[inline]
    fn take_from(from: &WireOffer) -> Self {
        match from.raw.ordinal() {
            1 => Self::Service(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferService>()
            })),

            2 => Self::Protocol(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferProtocol>()
            })),

            3 => Self::Directory(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferDirectory>()
            })),

            4 => Self::Storage(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferStorage>()
            })),

            5 => Self::Runner(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferRunner>()
            })),

            6 => Self::Resolver(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferResolver>()
            })),

            8 => Self::EventStream(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferEventStream>()
            })),

            9 => Self::Dictionary(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferDictionary>()
            })),

            10 => Self::Config(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireOfferConfiguration>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalOffer> for Option<Box<Offer>> {
    #[inline]
    fn take_from(from: &WireOptionalOffer) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`Offer`].
#[repr(transparent)]
pub struct WireOffer {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOffer {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod offer {
    pub enum Ref<'union> {
        Service(&'union crate::WireOfferService),

        Protocol(&'union crate::WireOfferProtocol),

        Directory(&'union crate::WireOfferDirectory),

        Storage(&'union crate::WireOfferStorage),

        Runner(&'union crate::WireOfferRunner),

        Resolver(&'union crate::WireOfferResolver),

        EventStream(&'union crate::WireOfferEventStream),

        Dictionary(&'union crate::WireOfferDictionary),

        Config(&'union crate::WireOfferConfiguration),

        UnknownOrdinal_(u64),
    }
}

impl WireOffer {
    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
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferService>(raw, decoder)?
            }

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferProtocol>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDirectory>(
                raw, decoder,
            )?,

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferStorage>(raw, decoder)?
            }

            5 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferRunner>(raw, decoder)?
            }

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferResolver>(
                raw, decoder,
            )?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferEventStream>(
                raw, decoder,
            )?,

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDictionary>(
                raw, decoder,
            )?,

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferConfiguration>(
                raw, decoder,
            )?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOffer {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalOffer {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalOffer {
    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> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalOffer
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferService>(raw, decoder)?
            }

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferProtocol>(
                raw, decoder,
            )?,

            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDirectory>(
                raw, decoder,
            )?,

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferStorage>(raw, decoder)?
            }

            5 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferRunner>(raw, decoder)?
            }

            6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferResolver>(
                raw, decoder,
            )?,

            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferEventStream>(
                raw, decoder,
            )?,

            9 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferDictionary>(
                raw, decoder,
            )?,

            10 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireOfferConfiguration>(
                raw, decoder,
            )?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalOffer {
    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)]
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.source_name.is_some() {
            return 1;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.target_name.is_some() {
            return 3;
        }

        0
    }
}

impl ::fidl_next::Encodable for RunnerRegistration {
    type Encoded = WireRunnerRegistration;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireRunnerRegistration> for RunnerRegistration {
    #[inline]
    fn take_from(from: &WireRunnerRegistration) -> Self {
        Self {
            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

            source: from.source().map(::fidl_next::TakeFrom::take_from),

            target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`RunnerRegistration`].
#[repr(C)]
pub struct WireRunnerRegistration {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireRunnerRegistration {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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 WireRunnerRegistration {
    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireRunnerRegistration {
    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)]
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.resolver.is_some() {
            return 1;
        }

        if self.source.is_some() {
            return 2;
        }

        if self.scheme.is_some() {
            return 3;
        }

        0
    }
}

impl ::fidl_next::Encodable for ResolverRegistration {
    type Encoded = WireResolverRegistration;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(scheme) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireResolverRegistration> for ResolverRegistration {
    #[inline]
    fn take_from(from: &WireResolverRegistration) -> Self {
        Self {
            resolver: from.resolver().map(::fidl_next::TakeFrom::take_from),

            source: from.source().map(::fidl_next::TakeFrom::take_from),

            scheme: from.scheme().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`ResolverRegistration`].
#[repr(C)]
pub struct WireResolverRegistration {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireResolverRegistration {
    #[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
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>(
                        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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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 WireResolverRegistration {
    pub fn resolver(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn scheme(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireResolverRegistration {
    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)]
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.source.is_some() {
            return 1;
        }

        if self.source_name.is_some() {
            return 2;
        }

        if self.target_name.is_some() {
            return 3;
        }

        0
    }
}

impl ::fidl_next::Encodable for DebugProtocolRegistration {
    type Encoded = WireDebugProtocolRegistration;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(target_name) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireDebugProtocolRegistration> for DebugProtocolRegistration {
    #[inline]
    fn take_from(from: &WireDebugProtocolRegistration) -> Self {
        Self {
            source: from.source().map(::fidl_next::TakeFrom::take_from),

            source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

            target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`DebugProtocolRegistration`].
#[repr(C)]
pub struct WireDebugProtocolRegistration {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireDebugProtocolRegistration {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString>(
                        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>(
                        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 WireDebugProtocolRegistration {
    pub fn source(&self) -> Option<&crate::WireRef> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn source_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn target_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireDebugProtocolRegistration {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DebugRegistration
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDebugRegistration { raw } = 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 Box<DebugRegistration> {
    type EncodedOption = WireOptionalDebugRegistration;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DebugRegistration>
where
    ___E: ?Sized,
    DebugRegistration: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalDebugRegistration { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDebugRegistration> for DebugRegistration {
    #[inline]
    fn take_from(from: &WireDebugRegistration) -> Self {
        match from.raw.ordinal() {
            1 => Self::Protocol(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDebugProtocolRegistration>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalDebugRegistration> for Option<Box<DebugRegistration>> {
    #[inline]
    fn take_from(from: &WireOptionalDebugRegistration) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`DebugRegistration`].
#[repr(transparent)]
pub struct WireDebugRegistration {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireDebugRegistration {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod debug_registration {
    pub enum Ref<'union> {
        Protocol(&'union crate::WireDebugProtocolRegistration),

        UnknownOrdinal_(u64),
    }
}

impl WireDebugRegistration {
    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
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDebugProtocolRegistration>(
                    raw, decoder,
                )?
            }

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireDebugRegistration {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalDebugRegistration {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalDebugRegistration {
    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> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDebugRegistration
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDebugProtocolRegistration>(
                    raw, decoder,
                )?
            }

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalDebugRegistration {
    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)]
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.name.is_some() {
            return 1;
        }

        if self.extends.is_some() {
            return 2;
        }

        if self.runners.is_some() {
            return 3;
        }

        if self.resolvers.is_some() {
            return 4;
        }

        if self.debug_capabilities.is_some() {
            return 5;
        }

        if self.stop_timeout_ms.is_some() {
            return 6;
        }

        0
    }
}

impl ::fidl_next::Encodable for Environment {
    type Encoded = WireEnvironment;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(stop_timeout_ms) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireEnvironment> for Environment {
    #[inline]
    fn take_from(from: &WireEnvironment) -> Self {
        Self {
            name: from.name().map(::fidl_next::TakeFrom::take_from),

            extends: from.extends().map(::fidl_next::TakeFrom::take_from),

            runners: from.runners().map(::fidl_next::TakeFrom::take_from),

            resolvers: from.resolvers().map(::fidl_next::TakeFrom::take_from),

            debug_capabilities: from.debug_capabilities().map(::fidl_next::TakeFrom::take_from),

            stop_timeout_ms: from.stop_timeout_ms().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`Environment`].
#[repr(C)]
pub struct WireEnvironment {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireEnvironment {
    #[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
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>(
                        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<crate::WireRunnerRegistration>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireResolverRegistration>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireDebugRegistration>,
                    >(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 WireEnvironment {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        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<crate::WireRunnerRegistration>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn resolvers(&self) -> Option<&::fidl_next::WireVector<crate::WireResolverRegistration>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn debug_capabilities(
        &self,
    ) -> Option<&::fidl_next::WireVector<crate::WireDebugRegistration>> {
        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 ::core::fmt::Debug for WireEnvironment {
    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)]
pub struct ConfigSourceCapabilities {}

impl ConfigSourceCapabilities {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for ConfigSourceCapabilities {
    type Encoded = WireConfigSourceCapabilities;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConfigSourceCapabilities> for ConfigSourceCapabilities {
    #[inline]
    fn take_from(from: &WireConfigSourceCapabilities) -> Self {
        Self {}
    }
}

/// The wire type corresponding to [`ConfigSourceCapabilities`].
#[repr(C)]
pub struct WireConfigSourceCapabilities {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigSourceCapabilities {
    #[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
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 WireConfigSourceCapabilities {}

impl ::core::fmt::Debug for WireConfigSourceCapabilities {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ConfigValueSource
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireConfigValueSource { raw } = 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 Box<ConfigValueSource> {
    type EncodedOption = WireOptionalConfigValueSource;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ConfigValueSource>
where
    ___E: ?Sized,
    ConfigValueSource: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalConfigValueSource { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireConfigValueSource> for ConfigValueSource {
    #[inline]
    fn take_from(from: &WireConfigValueSource) -> Self {
        match from.raw.ordinal() {
            1 => Self::PackagePath(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next::WireString>()
            })),

            2 => Self::Capabilities(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireConfigSourceCapabilities>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalConfigValueSource> for Option<Box<ConfigValueSource>> {
    #[inline]
    fn take_from(from: &WireOptionalConfigValueSource) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`ConfigValueSource`].
#[repr(transparent)]
pub struct WireConfigValueSource {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigValueSource {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod config_value_source {
    pub enum Ref<'union> {
        PackagePath(&'union ::fidl_next::WireString),

        Capabilities(&'union crate::WireConfigSourceCapabilities),

        UnknownOrdinal_(u64),
    }
}

impl WireConfigValueSource {
    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
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString>(raw, decoder)?
            }

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfigSourceCapabilities>(
                raw, decoder,
            )?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireConfigValueSource {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalConfigValueSource {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalConfigValueSource {
    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> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConfigValueSource
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString>(raw, decoder)?
            }

            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfigSourceCapabilities>(
                raw, decoder,
            )?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalConfigValueSource {
    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)]
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.fields.is_some() {
            return 1;
        }

        if self.checksum.is_some() {
            return 2;
        }

        if self.value_source.is_some() {
            return 3;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigSchema {
    type Encoded = WireConfigSchema;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(value_source) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireConfigSchema> for ConfigSchema {
    #[inline]
    fn take_from(from: &WireConfigSchema) -> Self {
        Self {
            fields: from.fields().map(::fidl_next::TakeFrom::take_from),

            checksum: from.checksum().map(::fidl_next::TakeFrom::take_from),

            value_source: from.value_source().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`ConfigSchema`].
#[repr(C)]
pub struct WireConfigSchema {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigSchema {
    #[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
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<crate::WireConfigField>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigChecksum>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigValueSource>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireConfigSchema {
    pub fn fields(&self) -> Option<&::fidl_next::WireVector<crate::WireConfigField>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn checksum(&self) -> Option<&crate::WireConfigChecksum> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn value_source(&self) -> Option<&crate::WireConfigValueSource> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireConfigSchema {
    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)]
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.program.is_some() {
            return 1;
        }

        if self.uses.is_some() {
            return 2;
        }

        if self.exposes.is_some() {
            return 3;
        }

        if self.offers.is_some() {
            return 4;
        }

        if self.capabilities.is_some() {
            return 5;
        }

        if self.children.is_some() {
            return 6;
        }

        if self.collections.is_some() {
            return 7;
        }

        if self.environments.is_some() {
            return 8;
        }

        if self.facets.is_some() {
            return 9;
        }

        if self.config.is_some() {
            return 10;
        }

        0
    }
}

impl ::fidl_next::Encodable for Component {
    type Encoded = WireComponent;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                10 => {
                    if let Some(config) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireComponent> for Component {
    #[inline]
    fn take_from(from: &WireComponent) -> Self {
        Self {
            program: from.program().map(::fidl_next::TakeFrom::take_from),

            uses: from.uses().map(::fidl_next::TakeFrom::take_from),

            exposes: from.exposes().map(::fidl_next::TakeFrom::take_from),

            offers: from.offers().map(::fidl_next::TakeFrom::take_from),

            capabilities: from.capabilities().map(::fidl_next::TakeFrom::take_from),

            children: from.children().map(::fidl_next::TakeFrom::take_from),

            collections: from.collections().map(::fidl_next::TakeFrom::take_from),

            environments: from.environments().map(::fidl_next::TakeFrom::take_from),

            facets: from.facets().map(::fidl_next::TakeFrom::take_from),

            config: from.config().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`Component`].
#[repr(C)]
pub struct WireComponent {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireComponent {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireUse>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireExpose>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireOffer>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireCapability>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireChild>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireCollection>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireEnvironment>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_data::WireDictionary,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigSchema>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireComponent {
    pub fn program(&self) -> Option<&crate::WireProgram> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn uses(&self) -> Option<&::fidl_next::WireVector<crate::WireUse>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn exposes(&self) -> Option<&::fidl_next::WireVector<crate::WireExpose>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn offers(&self) -> Option<&::fidl_next::WireVector<crate::WireOffer>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn capabilities(&self) -> Option<&::fidl_next::WireVector<crate::WireCapability>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn children(&self) -> Option<&::fidl_next::WireVector<crate::WireChild>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn collections(&self) -> Option<&::fidl_next::WireVector<crate::WireCollection>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn environments(&self) -> Option<&::fidl_next::WireVector<crate::WireEnvironment>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn facets(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn config(&self) -> Option<&crate::WireConfigSchema> {
        unsafe { Some(self.table.get(10)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireComponent {
    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)]
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;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(value) = &mut 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 ::fidl_next::TakeFrom<WireConfigValueSpec> for ConfigValueSpec {
    #[inline]
    fn take_from(from: &WireConfigValueSpec) -> Self {
        Self { value: from.value().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`ConfigValueSpec`].
#[repr(C)]
pub struct WireConfigValueSpec {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigValueSpec {
    #[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
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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireConfigValueSpec {
    pub fn value(&self) -> Option<&crate::WireConfigValue> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireConfigValueSpec {
    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)]
pub struct ConfigValuesData {
    pub values: Option<Vec<crate::ConfigValueSpec>>,

    pub checksum: Option<crate::ConfigChecksum>,
}

impl ConfigValuesData {
    fn __max_ordinal(&self) -> usize {
        if self.values.is_some() {
            return 1;
        }

        if self.checksum.is_some() {
            return 2;
        }

        0
    }
}

impl ::fidl_next::Encodable for ConfigValuesData {
    type Encoded = WireConfigValuesData;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(checksum) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireConfigValuesData> for ConfigValuesData {
    #[inline]
    fn take_from(from: &WireConfigValuesData) -> Self {
        Self {
            values: from.values().map(::fidl_next::TakeFrom::take_from),

            checksum: from.checksum().map(::fidl_next::TakeFrom::take_from),
        }
    }
}

/// The wire type corresponding to [`ConfigValuesData`].
#[repr(C)]
pub struct WireConfigValuesData {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireConfigValuesData {
    #[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
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<crate::WireConfigValueSpec>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireConfigChecksum>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl WireConfigValuesData {
    pub fn values(&self) -> Option<&::fidl_next::WireVector<crate::WireConfigValueSpec>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn checksum(&self) -> Option<&crate::WireConfigChecksum> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireConfigValuesData {
    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)]
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;
}

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::ZeroPadding::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                1 => {
                    if let Some(event_name) = &mut 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 ::fidl_next::TakeFrom<WireEventSubscription> for EventSubscription {
    #[inline]
    fn take_from(from: &WireEventSubscription) -> Self {
        Self { event_name: from.event_name().map(::fidl_next::TakeFrom::take_from) }
    }
}

/// The wire type corresponding to [`EventSubscription`].
#[repr(C)]
pub struct WireEventSubscription {
    table: ::fidl_next::WireTable,
}

unsafe impl ::fidl_next::ZeroPadding for WireEventSubscription {
    #[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
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>(
                        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 WireEventSubscription {
    pub fn event_name(&self) -> Option<&::fidl_next::WireString> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireEventSubscription {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for LayoutParameter
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireLayoutParameter { raw } = 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 Box<LayoutParameter> {
    type EncodedOption = WireOptionalLayoutParameter;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<LayoutParameter>
where
    ___E: ?Sized,
    LayoutParameter: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalLayoutParameter { raw } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLayoutParameter> for LayoutParameter {
    #[inline]
    fn take_from(from: &WireLayoutParameter) -> Self {
        match from.raw.ordinal() {
            1 => Self::NestedType(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireConfigType>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl ::fidl_next::TakeFrom<WireOptionalLayoutParameter> for Option<Box<LayoutParameter>> {
    #[inline]
    fn take_from(from: &WireOptionalLayoutParameter) -> Self {
        if let Some(inner) = from.as_ref() {
            Some(::fidl_next::TakeFrom::take_from(inner))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`LayoutParameter`].
#[repr(transparent)]
pub struct WireLayoutParameter {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireLayoutParameter {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod layout_parameter {
    pub enum Ref<'union> {
        NestedType(&'union crate::WireConfigType),

        UnknownOrdinal_(u64),
    }
}

impl WireLayoutParameter {
    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
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfigType>(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireLayoutParameter {
    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 {
    raw: ::fidl_next::RawWireUnion,
}

unsafe impl ::fidl_next::ZeroPadding for WireOptionalLayoutParameter {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl WireOptionalLayoutParameter {
    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> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalLayoutParameter
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConfigType>(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalLayoutParameter {
    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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolvedConfigField
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                key,
                value,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.key, encoder, key)?;

        ::fidl_next::Encode::encode(&mut self.value, encoder, value)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ResolvedConfigField> {
    type EncodedOption = ::fidl_next::WireBox<WireResolvedConfigField>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ResolvedConfigField>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfigField: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireResolvedConfigField> for ResolvedConfigField {
    #[inline]
    fn take_from(from: &WireResolvedConfigField) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

            value: ::fidl_next::TakeFrom::take_from(&from.value),
        }
    }
}

/// The wire type corresponding to [`ResolvedConfigField`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolvedConfigField {
    pub key: ::fidl_next::WireString,

    pub value: crate::WireConfigValue,
}

unsafe impl ::fidl_next::ZeroPadding for WireResolvedConfigField {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolvedConfigField
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;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolvedConfig
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                fields,
                checksum,

            } = out;
        }

        ::fidl_next::Encode::encode(&mut self.fields, encoder, fields)?;

        ::fidl_next::Encode::encode(&mut self.checksum, encoder, checksum)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ResolvedConfig> {
    type EncodedOption = ::fidl_next::WireBox<WireResolvedConfig>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<ResolvedConfig>
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolvedConfig: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<&mut Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireResolvedConfig> for ResolvedConfig {
    #[inline]
    fn take_from(from: &WireResolvedConfig) -> Self {
        Self {
            fields: ::fidl_next::TakeFrom::take_from(&from.fields),

            checksum: ::fidl_next::TakeFrom::take_from(&from.checksum),
        }
    }
}

/// The wire type corresponding to [`ResolvedConfig`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolvedConfig {
    pub fields: ::fidl_next::WireVector<crate::WireResolvedConfigField>,

    pub checksum: crate::WireConfigChecksum,
}

unsafe impl ::fidl_next::ZeroPadding for WireResolvedConfig {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolvedConfig
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 ::fidl_next::TakeFrom<crate::WireAllowedOffers>
        for ::fidl_fuchsia_component_decl::AllowedOffers
    {
        #[inline]
        fn take_from(from: &crate::WireAllowedOffers) -> Self {
            match crate::AllowedOffers::from(*from) {
                crate::AllowedOffers::StaticOnly => Self::StaticOnly,

                crate::AllowedOffers::StaticAndDynamic => Self::StaticAndDynamic,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireAvailability>
        for ::fidl_fuchsia_component_decl::Availability
    {
        #[inline]
        fn take_from(from: &crate::WireAvailability) -> Self {
            match crate::Availability::from(*from) {
                crate::Availability::Required => Self::Required,

                crate::Availability::Optional => Self::Optional,

                crate::Availability::SameAsTarget => Self::SameAsTarget,

                crate::Availability::Transitional => Self::Transitional,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireService> for ::fidl_fuchsia_component_decl::Service {
        #[inline]
        fn take_from(from: &crate::WireService) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDirectory> for ::fidl_fuchsia_component_decl::Directory {
        #[inline]
        fn take_from(from: &crate::WireDirectory) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                rights: from.rights().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireParentRef> for ::fidl_fuchsia_component_decl::ParentRef {
        #[inline]
        fn take_from(from: &crate::WireParentRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireSelfRef> for ::fidl_fuchsia_component_decl::SelfRef {
        #[inline]
        fn take_from(from: &crate::WireSelfRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireChildRef> for ::fidl_fuchsia_component_decl::ChildRef {
        #[inline]
        fn take_from(from: &crate::WireChildRef) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

                collection: ::fidl_next::TakeFrom::take_from(&from.collection),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCollectionRef>
        for ::fidl_fuchsia_component_decl::CollectionRef
    {
        #[inline]
        fn take_from(from: &crate::WireCollectionRef) -> Self {
            Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireFrameworkRef>
        for ::fidl_fuchsia_component_decl::FrameworkRef
    {
        #[inline]
        fn take_from(from: &crate::WireFrameworkRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapabilityRef>
        for ::fidl_fuchsia_component_decl::CapabilityRef
    {
        #[inline]
        fn take_from(from: &crate::WireCapabilityRef) -> Self {
            Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDebugRef> for ::fidl_fuchsia_component_decl::DebugRef {
        #[inline]
        fn take_from(from: &crate::WireDebugRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireVoidRef> for ::fidl_fuchsia_component_decl::VoidRef {
        #[inline]
        fn take_from(from: &crate::WireVoidRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireStorageId> for ::fidl_fuchsia_component_decl::StorageId {
        #[inline]
        fn take_from(from: &crate::WireStorageId) -> Self {
            match crate::StorageId::from(*from) {
                crate::StorageId::StaticInstanceId => Self::StaticInstanceId,

                crate::StorageId::StaticInstanceIdOrMoniker => Self::StaticInstanceIdOrMoniker,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRunner> for ::fidl_fuchsia_component_decl::Runner {
        #[inline]
        fn take_from(from: &crate::WireRunner) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolver> for ::fidl_fuchsia_component_decl::Resolver {
        #[inline]
        fn take_from(from: &crate::WireResolver) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEventStream> for ::fidl_fuchsia_component_decl::EventStream {
        #[inline]
        fn take_from(from: &crate::WireEventStream) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigSingleValue>
        for ::fidl_fuchsia_component_decl::ConfigSingleValue
    {
        #[inline]
        fn take_from(from: &crate::WireConfigSingleValue) -> Self {
            match from.as_ref() {
                crate::config_single_value::Ref::Bool(value) => {
                    Self::Bool(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Uint8(value) => {
                    Self::Uint8(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Uint16(value) => {
                    Self::Uint16(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Uint32(value) => {
                    Self::Uint32(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Uint64(value) => {
                    Self::Uint64(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Int8(value) => {
                    Self::Int8(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Int16(value) => {
                    Self::Int16(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Int32(value) => {
                    Self::Int32(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::Int64(value) => {
                    Self::Int64(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::String(value) => {
                    Self::String(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_single_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalConfigSingleValue>
        for Option<Box<::fidl_fuchsia_component_decl::ConfigSingleValue>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalConfigSingleValue) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigVectorValue>
        for ::fidl_fuchsia_component_decl::ConfigVectorValue
    {
        #[inline]
        fn take_from(from: &crate::WireConfigVectorValue) -> Self {
            match from.as_ref() {
                crate::config_vector_value::Ref::BoolVector(value) => {
                    Self::BoolVector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Uint8Vector(value) => {
                    Self::Uint8Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Uint16Vector(value) => {
                    Self::Uint16Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Uint32Vector(value) => {
                    Self::Uint32Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Uint64Vector(value) => {
                    Self::Uint64Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Int8Vector(value) => {
                    Self::Int8Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Int16Vector(value) => {
                    Self::Int16Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Int32Vector(value) => {
                    Self::Int32Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::Int64Vector(value) => {
                    Self::Int64Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::StringVector(value) => {
                    Self::StringVector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_vector_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalConfigVectorValue>
        for Option<Box<::fidl_fuchsia_component_decl::ConfigVectorValue>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalConfigVectorValue) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigValue> for ::fidl_fuchsia_component_decl::ConfigValue {
        #[inline]
        fn take_from(from: &crate::WireConfigValue) -> Self {
            match from.as_ref() {
                crate::config_value::Ref::Single(value) => {
                    Self::Single(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_value::Ref::Vector(value) => {
                    Self::Vector(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalConfigValue>
        for Option<Box<::fidl_fuchsia_component_decl::ConfigValue>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalConfigValue) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfiguration>
        for ::fidl_fuchsia_component_decl::Configuration
    {
        #[inline]
        fn take_from(from: &crate::WireConfiguration) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                value: from.value().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDeliveryType>
        for ::fidl_fuchsia_component_decl::DeliveryType
    {
        #[inline]
        fn take_from(from: &crate::WireDeliveryType) -> 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 ::fidl_next::TakeFrom<crate::WireProtocol> for ::fidl_fuchsia_component_decl::Protocol {
        #[inline]
        fn take_from(from: &crate::WireProtocol) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                delivery: from.delivery().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEnvironmentRef>
        for ::fidl_fuchsia_component_decl::EnvironmentRef
    {
        #[inline]
        fn take_from(from: &crate::WireEnvironmentRef) -> Self {
            Self {}
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRef> for ::fidl_fuchsia_component_decl::Ref {
        #[inline]
        fn take_from(from: &crate::WireRef) -> Self {
            match from.as_ref() {
                crate::ref_::Ref::Parent(value) => {
                    Self::Parent(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Self_(value) => {
                    Self::Self_(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Child(value) => {
                    Self::Child(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Collection(value) => {
                    Self::Collection(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Framework(value) => {
                    Self::Framework(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Capability(value) => {
                    Self::Capability(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Debug(value) => {
                    Self::Debug(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::VoidType(value) => {
                    Self::VoidType(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::Environment(value) => {
                    Self::Environment(::fidl_next::TakeFrom::take_from(value))
                }

                crate::ref_::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalRef>
        for Option<Box<::fidl_fuchsia_component_decl::Ref>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalRef) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireStorage> for ::fidl_fuchsia_component_decl::Storage {
        #[inline]
        fn take_from(from: &crate::WireStorage) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                backing_dir: from.backing_dir().map(::fidl_next::TakeFrom::take_from),

                subdir: from.subdir().map(::fidl_next::TakeFrom::take_from),

                storage_id: from.storage_id().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDictionary> for ::fidl_fuchsia_component_decl::Dictionary {
        #[inline]
        fn take_from(from: &crate::WireDictionary) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                source_path: from.source_path().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCapability> for ::fidl_fuchsia_component_decl::Capability {
        #[inline]
        fn take_from(from: &crate::WireCapability) -> Self {
            match from.as_ref() {
                crate::capability::Ref::Service(value) => {
                    Self::Service(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Protocol(value) => {
                    Self::Protocol(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Storage(value) => {
                    Self::Storage(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Runner(value) => {
                    Self::Runner(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Resolver(value) => {
                    Self::Resolver(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::EventStream(value) => {
                    Self::EventStream(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Dictionary(value) => {
                    Self::Dictionary(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::Config(value) => {
                    Self::Config(::fidl_next::TakeFrom::take_from(value))
                }

                crate::capability::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalCapability>
        for Option<Box<::fidl_fuchsia_component_decl::Capability>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalCapability) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireStartupMode> for ::fidl_fuchsia_component_decl::StartupMode {
        #[inline]
        fn take_from(from: &crate::WireStartupMode) -> Self {
            match crate::StartupMode::from(*from) {
                crate::StartupMode::Lazy => Self::Lazy,

                crate::StartupMode::Eager => Self::Eager,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOnTerminate> for ::fidl_fuchsia_component_decl::OnTerminate {
        #[inline]
        fn take_from(from: &crate::WireOnTerminate) -> Self {
            match crate::OnTerminate::from(*from) {
                crate::OnTerminate::None => Self::None,

                crate::OnTerminate::Reboot => Self::Reboot,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigOverride>
        for ::fidl_fuchsia_component_decl::ConfigOverride
    {
        #[inline]
        fn take_from(from: &crate::WireConfigOverride) -> Self {
            Self {
                key: from.key().map(::fidl_next::TakeFrom::take_from),

                value: from.value().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireChild> for ::fidl_fuchsia_component_decl::Child {
        #[inline]
        fn take_from(from: &crate::WireChild) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                url: from.url().map(::fidl_next::TakeFrom::take_from),

                startup: from.startup().map(::fidl_next::TakeFrom::take_from),

                environment: from.environment().map(::fidl_next::TakeFrom::take_from),

                on_terminate: from.on_terminate().map(::fidl_next::TakeFrom::take_from),

                config_overrides: from.config_overrides().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDurability> for ::fidl_fuchsia_component_decl::Durability {
        #[inline]
        fn take_from(from: &crate::WireDurability) -> Self {
            match crate::Durability::from(*from) {
                crate::Durability::Transient => Self::Transient,

                crate::Durability::SingleRun => Self::SingleRun,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCollection> for ::fidl_fuchsia_component_decl::Collection {
        #[inline]
        fn take_from(from: &crate::WireCollection) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                durability: from.durability().map(::fidl_next::TakeFrom::take_from),

                environment: from.environment().map(::fidl_next::TakeFrom::take_from),

                allowed_offers: from.allowed_offers().map(::fidl_next::TakeFrom::take_from),

                allow_long_names: from.allow_long_names().map(::fidl_next::TakeFrom::take_from),

                persistent_storage: from.persistent_storage().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDependencyType>
        for ::fidl_fuchsia_component_decl::DependencyType
    {
        #[inline]
        fn take_from(from: &crate::WireDependencyType) -> Self {
            match crate::DependencyType::from(*from) {
                crate::DependencyType::Strong => Self::Strong,

                crate::DependencyType::Weak => Self::Weak,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNameMapping> for ::fidl_fuchsia_component_decl::NameMapping {
        #[inline]
        fn take_from(from: &crate::WireNameMapping) -> Self {
            Self {
                source_name: ::fidl_next::TakeFrom::take_from(&from.source_name),

                target_name: ::fidl_next::TakeFrom::take_from(&from.target_name),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEnvironmentExtends>
        for ::fidl_fuchsia_component_decl::EnvironmentExtends
    {
        #[inline]
        fn take_from(from: &crate::WireEnvironmentExtends) -> Self {
            match crate::EnvironmentExtends::from(*from) {
                crate::EnvironmentExtends::None => Self::None,

                crate::EnvironmentExtends::Realm => Self::Realm,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigTypeLayout>
        for ::fidl_fuchsia_component_decl::ConfigTypeLayout
    {
        #[inline]
        fn take_from(from: &crate::WireConfigTypeLayout) -> 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 ::fidl_next::TakeFrom<crate::WireLayoutConstraint>
        for ::fidl_fuchsia_component_decl::LayoutConstraint
    {
        #[inline]
        fn take_from(from: &crate::WireLayoutConstraint) -> Self {
            match from.as_ref() {
                crate::layout_constraint::Ref::MaxSize(value) => {
                    Self::MaxSize(::fidl_next::TakeFrom::take_from(value))
                }

                crate::layout_constraint::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalLayoutConstraint>
        for Option<Box<::fidl_fuchsia_component_decl::LayoutConstraint>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalLayoutConstraint) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigType> for ::fidl_fuchsia_component_decl::ConfigType {
        #[inline]
        fn take_from(from: &crate::WireConfigType) -> Self {
            Self {
                layout: ::fidl_next::TakeFrom::take_from(&from.layout),

                parameters: ::fidl_next::TakeFrom::take_from(&from.parameters),

                constraints: ::fidl_next::TakeFrom::take_from(&from.constraints),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigChecksum>
        for ::fidl_fuchsia_component_decl::ConfigChecksum
    {
        #[inline]
        fn take_from(from: &crate::WireConfigChecksum) -> Self {
            match from.as_ref() {
                crate::config_checksum::Ref::Sha256(value) => {
                    Self::Sha256(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_checksum::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalConfigChecksum>
        for Option<Box<::fidl_fuchsia_component_decl::ConfigChecksum>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalConfigChecksum) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseStorage> for ::fidl_fuchsia_component_decl::UseStorage {
        #[inline]
        fn take_from(from: &crate::WireUseStorage) -> Self {
            Self {
                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_path: from.target_path().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigMutability>
        for ::fidl_fuchsia_component_decl::ConfigMutability
    {
        #[inline]
        fn take_from(from: &crate::WireConfigMutability) -> Self {
            Self::from_bits_retain(from.value.into())
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigField> for ::fidl_fuchsia_component_decl::ConfigField {
        #[inline]
        fn take_from(from: &crate::WireConfigField) -> Self {
            Self {
                key: from.key().map(::fidl_next::TakeFrom::take_from),

                type_: from.type_().map(::fidl_next::TakeFrom::take_from),

                mutability: from.mutability().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireProgram> for ::fidl_fuchsia_component_decl::Program {
        #[inline]
        fn take_from(from: &crate::WireProgram) -> Self {
            Self {
                runner: from.runner().map(::fidl_next::TakeFrom::take_from),

                info: from.info().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseService> for ::fidl_fuchsia_component_decl::UseService {
        #[inline]
        fn take_from(from: &crate::WireUseService) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_path: from.target_path().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseProtocol> for ::fidl_fuchsia_component_decl::UseProtocol {
        #[inline]
        fn take_from(from: &crate::WireUseProtocol) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_path: from.target_path().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseDirectory>
        for ::fidl_fuchsia_component_decl::UseDirectory
    {
        #[inline]
        fn take_from(from: &crate::WireUseDirectory) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_path: from.target_path().map(::fidl_next::TakeFrom::take_from),

                rights: from.rights().map(::fidl_next::TakeFrom::take_from),

                subdir: from.subdir().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseEventStream>
        for ::fidl_fuchsia_component_decl::UseEventStream
    {
        #[inline]
        fn take_from(from: &crate::WireUseEventStream) -> Self {
            Self {
                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                scope: from.scope().map(::fidl_next::TakeFrom::take_from),

                target_path: from.target_path().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                filter: from.filter().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseRunner> for ::fidl_fuchsia_component_decl::UseRunner {
        #[inline]
        fn take_from(from: &crate::WireUseRunner) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUseConfiguration>
        for ::fidl_fuchsia_component_decl::UseConfiguration
    {
        #[inline]
        fn take_from(from: &crate::WireUseConfiguration) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                type_: from.type_().map(::fidl_next::TakeFrom::take_from),

                default: from.default().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUse> for ::fidl_fuchsia_component_decl::Use {
        #[inline]
        fn take_from(from: &crate::WireUse) -> Self {
            match from.as_ref() {
                crate::use_::Ref::Service(value) => {
                    Self::Service(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::Protocol(value) => {
                    Self::Protocol(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::Storage(value) => {
                    Self::Storage(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::EventStream(value) => {
                    Self::EventStream(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::Runner(value) => {
                    Self::Runner(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::Config(value) => {
                    Self::Config(::fidl_next::TakeFrom::take_from(value))
                }

                crate::use_::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalUse>
        for Option<Box<::fidl_fuchsia_component_decl::Use>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalUse) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeService>
        for ::fidl_fuchsia_component_decl::ExposeService
    {
        #[inline]
        fn take_from(from: &crate::WireExposeService) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeProtocol>
        for ::fidl_fuchsia_component_decl::ExposeProtocol
    {
        #[inline]
        fn take_from(from: &crate::WireExposeProtocol) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeDirectory>
        for ::fidl_fuchsia_component_decl::ExposeDirectory
    {
        #[inline]
        fn take_from(from: &crate::WireExposeDirectory) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                rights: from.rights().map(::fidl_next::TakeFrom::take_from),

                subdir: from.subdir().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeRunner>
        for ::fidl_fuchsia_component_decl::ExposeRunner
    {
        #[inline]
        fn take_from(from: &crate::WireExposeRunner) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeResolver>
        for ::fidl_fuchsia_component_decl::ExposeResolver
    {
        #[inline]
        fn take_from(from: &crate::WireExposeResolver) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeDictionary>
        for ::fidl_fuchsia_component_decl::ExposeDictionary
    {
        #[inline]
        fn take_from(from: &crate::WireExposeDictionary) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExposeConfiguration>
        for ::fidl_fuchsia_component_decl::ExposeConfiguration
    {
        #[inline]
        fn take_from(from: &crate::WireExposeConfiguration) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireExpose> for ::fidl_fuchsia_component_decl::Expose {
        #[inline]
        fn take_from(from: &crate::WireExpose) -> Self {
            match from.as_ref() {
                crate::expose::Ref::Service(value) => {
                    Self::Service(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Protocol(value) => {
                    Self::Protocol(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Runner(value) => {
                    Self::Runner(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Resolver(value) => {
                    Self::Resolver(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Dictionary(value) => {
                    Self::Dictionary(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::Config(value) => {
                    Self::Config(::fidl_next::TakeFrom::take_from(value))
                }

                crate::expose::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalExpose>
        for Option<Box<::fidl_fuchsia_component_decl::Expose>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalExpose) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferService>
        for ::fidl_fuchsia_component_decl::OfferService
    {
        #[inline]
        fn take_from(from: &crate::WireOfferService) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                source_instance_filter: from
                    .source_instance_filter()
                    .map(::fidl_next::TakeFrom::take_from),

                renamed_instances: from.renamed_instances().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferProtocol>
        for ::fidl_fuchsia_component_decl::OfferProtocol
    {
        #[inline]
        fn take_from(from: &crate::WireOfferProtocol) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferDirectory>
        for ::fidl_fuchsia_component_decl::OfferDirectory
    {
        #[inline]
        fn take_from(from: &crate::WireOfferDirectory) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                rights: from.rights().map(::fidl_next::TakeFrom::take_from),

                subdir: from.subdir().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferStorage>
        for ::fidl_fuchsia_component_decl::OfferStorage
    {
        #[inline]
        fn take_from(from: &crate::WireOfferStorage) -> Self {
            Self {
                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferRunner> for ::fidl_fuchsia_component_decl::OfferRunner {
        #[inline]
        fn take_from(from: &crate::WireOfferRunner) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferResolver>
        for ::fidl_fuchsia_component_decl::OfferResolver
    {
        #[inline]
        fn take_from(from: &crate::WireOfferResolver) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferEventStream>
        for ::fidl_fuchsia_component_decl::OfferEventStream
    {
        #[inline]
        fn take_from(from: &crate::WireOfferEventStream) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                scope: from.scope().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferDictionary>
        for ::fidl_fuchsia_component_decl::OfferDictionary
    {
        #[inline]
        fn take_from(from: &crate::WireOfferDictionary) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                dependency_type: from.dependency_type().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOfferConfiguration>
        for ::fidl_fuchsia_component_decl::OfferConfiguration
    {
        #[inline]
        fn take_from(from: &crate::WireOfferConfiguration) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target: from.target().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                availability: from.availability().map(::fidl_next::TakeFrom::take_from),

                source_dictionary: from.source_dictionary().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOffer> for ::fidl_fuchsia_component_decl::Offer {
        #[inline]
        fn take_from(from: &crate::WireOffer) -> Self {
            match from.as_ref() {
                crate::offer::Ref::Service(value) => {
                    Self::Service(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Protocol(value) => {
                    Self::Protocol(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Directory(value) => {
                    Self::Directory(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Storage(value) => {
                    Self::Storage(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Runner(value) => {
                    Self::Runner(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Resolver(value) => {
                    Self::Resolver(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::EventStream(value) => {
                    Self::EventStream(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Dictionary(value) => {
                    Self::Dictionary(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::Config(value) => {
                    Self::Config(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalOffer>
        for Option<Box<::fidl_fuchsia_component_decl::Offer>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalOffer) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRunnerRegistration>
        for ::fidl_fuchsia_component_decl::RunnerRegistration
    {
        #[inline]
        fn take_from(from: &crate::WireRunnerRegistration) -> Self {
            Self {
                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolverRegistration>
        for ::fidl_fuchsia_component_decl::ResolverRegistration
    {
        #[inline]
        fn take_from(from: &crate::WireResolverRegistration) -> Self {
            Self {
                resolver: from.resolver().map(::fidl_next::TakeFrom::take_from),

                source: from.source().map(::fidl_next::TakeFrom::take_from),

                scheme: from.scheme().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDebugProtocolRegistration>
        for ::fidl_fuchsia_component_decl::DebugProtocolRegistration
    {
        #[inline]
        fn take_from(from: &crate::WireDebugProtocolRegistration) -> Self {
            Self {
                source: from.source().map(::fidl_next::TakeFrom::take_from),

                source_name: from.source_name().map(::fidl_next::TakeFrom::take_from),

                target_name: from.target_name().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDebugRegistration>
        for ::fidl_fuchsia_component_decl::DebugRegistration
    {
        #[inline]
        fn take_from(from: &crate::WireDebugRegistration) -> Self {
            match from.as_ref() {
                crate::debug_registration::Ref::Protocol(value) => {
                    Self::Protocol(::fidl_next::TakeFrom::take_from(value))
                }

                crate::debug_registration::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalDebugRegistration>
        for Option<Box<::fidl_fuchsia_component_decl::DebugRegistration>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalDebugRegistration) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEnvironment> for ::fidl_fuchsia_component_decl::Environment {
        #[inline]
        fn take_from(from: &crate::WireEnvironment) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

                extends: from.extends().map(::fidl_next::TakeFrom::take_from),

                runners: from.runners().map(::fidl_next::TakeFrom::take_from),

                resolvers: from.resolvers().map(::fidl_next::TakeFrom::take_from),

                debug_capabilities: from.debug_capabilities().map(::fidl_next::TakeFrom::take_from),

                stop_timeout_ms: from.stop_timeout_ms().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigSourceCapabilities>
        for ::fidl_fuchsia_component_decl::ConfigSourceCapabilities
    {
        #[inline]
        fn take_from(from: &crate::WireConfigSourceCapabilities) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigValueSource>
        for ::fidl_fuchsia_component_decl::ConfigValueSource
    {
        #[inline]
        fn take_from(from: &crate::WireConfigValueSource) -> Self {
            match from.as_ref() {
                crate::config_value_source::Ref::PackagePath(value) => {
                    Self::PackagePath(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_value_source::Ref::Capabilities(value) => {
                    Self::Capabilities(::fidl_next::TakeFrom::take_from(value))
                }

                crate::config_value_source::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalConfigValueSource>
        for Option<Box<::fidl_fuchsia_component_decl::ConfigValueSource>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalConfigValueSource) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigSchema>
        for ::fidl_fuchsia_component_decl::ConfigSchema
    {
        #[inline]
        fn take_from(from: &crate::WireConfigSchema) -> Self {
            Self {
                fields: from.fields().map(::fidl_next::TakeFrom::take_from),

                checksum: from.checksum().map(::fidl_next::TakeFrom::take_from),

                value_source: from.value_source().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireComponent> for ::fidl_fuchsia_component_decl::Component {
        #[inline]
        fn take_from(from: &crate::WireComponent) -> Self {
            Self {
                program: from.program().map(::fidl_next::TakeFrom::take_from),

                uses: from.uses().map(::fidl_next::TakeFrom::take_from),

                exposes: from.exposes().map(::fidl_next::TakeFrom::take_from),

                offers: from.offers().map(::fidl_next::TakeFrom::take_from),

                capabilities: from.capabilities().map(::fidl_next::TakeFrom::take_from),

                children: from.children().map(::fidl_next::TakeFrom::take_from),

                collections: from.collections().map(::fidl_next::TakeFrom::take_from),

                environments: from.environments().map(::fidl_next::TakeFrom::take_from),

                facets: from.facets().map(::fidl_next::TakeFrom::take_from),

                config: from.config().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigValueSpec>
        for ::fidl_fuchsia_component_decl::ConfigValueSpec
    {
        #[inline]
        fn take_from(from: &crate::WireConfigValueSpec) -> Self {
            Self {
                value: from.value().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireConfigValuesData>
        for ::fidl_fuchsia_component_decl::ConfigValuesData
    {
        #[inline]
        fn take_from(from: &crate::WireConfigValuesData) -> Self {
            Self {
                values: from.values().map(::fidl_next::TakeFrom::take_from),

                checksum: from.checksum().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEventSubscription>
        for ::fidl_fuchsia_component_decl::EventSubscription
    {
        #[inline]
        fn take_from(from: &crate::WireEventSubscription) -> Self {
            Self {
                event_name: from.event_name().map(::fidl_next::TakeFrom::take_from),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLayoutParameter>
        for ::fidl_fuchsia_component_decl::LayoutParameter
    {
        #[inline]
        fn take_from(from: &crate::WireLayoutParameter) -> Self {
            match from.as_ref() {
                crate::layout_parameter::Ref::NestedType(value) => {
                    Self::NestedType(::fidl_next::TakeFrom::take_from(value))
                }

                crate::layout_parameter::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOptionalLayoutParameter>
        for Option<Box<::fidl_fuchsia_component_decl::LayoutParameter>>
    {
        #[inline]
        fn take_from(from: &crate::WireOptionalLayoutParameter) -> Self {
            if let Some(inner) = from.as_ref() {
                Some(::fidl_next::TakeFrom::take_from(inner))
            } else {
                None
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolvedConfigField>
        for ::fidl_fuchsia_component_decl::ResolvedConfigField
    {
        #[inline]
        fn take_from(from: &crate::WireResolvedConfigField) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

                value: ::fidl_next::TakeFrom::take_from(&from.value),
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolvedConfig>
        for ::fidl_fuchsia_component_decl::ResolvedConfig
    {
        #[inline]
        fn take_from(from: &crate::WireResolvedConfig) -> Self {
            Self {
                fields: ::fidl_next::TakeFrom::take_from(&from.fields),

                checksum: ::fidl_next::TakeFrom::take_from(&from.checksum),
            }
        }
    }
}