fidl_next_common_fuchsia_component_decl/

fidl_next_common_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)]

pub mod natural {

    #[doc = " The kinds of offers that can target the children in a collection.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum AllowedOffers {
        StaticOnly = 1,
        StaticAndDynamic = 2,
    }
    impl ::core::convert::TryFrom<u32> for AllowedOffers {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                1 => Ok(Self::StaticOnly),
                2 => Ok(Self::StaticAndDynamic),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AllowedOffers, ___E> for AllowedOffers
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AllowedOffers>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AllowedOffers, ___E> for &'a AllowedOffers
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AllowedOffers>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::AllowedOffers { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                AllowedOffers::StaticOnly => 1,

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

            Ok(())
        }
    }

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

                2 => Self::StaticAndDynamic,

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

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

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

    #[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(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum Availability {
        Required = 1,
        Optional = 2,
        SameAsTarget = 3,
        Transitional = 4,
    }
    impl ::core::convert::TryFrom<u32> for Availability {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                1 => Ok(Self::Required),
                2 => Ok(Self::Optional),
                3 => Ok(Self::SameAsTarget),
                4 => Ok(Self::Transitional),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Availability, ___E> for Availability
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Availability>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

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

                Availability::Optional => 2,

                Availability::SameAsTarget => 3,

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

            Ok(())
        }
    }

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

                2 => Self::Optional,

                3 => Self::SameAsTarget,

                4 => Self::Transitional,

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

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

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

    pub type Name = ::std::string::String;

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Service {
        pub name: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Service<'static>, ___E> for Service
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Service<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Service { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Service<'static>, ___E> for &'a Service
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Service<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Service { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Service<'de>> for Service {
        #[inline]
        fn from_wire(wire_: crate::wire::Service<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Directory {
        pub name: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,

        pub rights: ::core::option::Option<::fidl_next_common_fuchsia_io::natural::Operations>,
    }

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

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

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

                    2 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

                    2 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Directory<'de>> for Directory {
        #[inline]
        fn from_wire(wire_: crate::wire::Directory<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

                rights: rights.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
                    })
                }),
            }
        }
    }

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

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

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

    #[doc = " A reference to a component\'s parent instance.\n"]
    pub type ParentRef = ();

    #[doc = " A reference to the component itself.\n"]
    pub type SelfRef = ();

    pub type ChildName = ::std::string::String;

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

        pub collection: ::core::option::Option<::std::string::String>,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ChildRef<'static>, ___E> for ChildRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ChildRef {
                    name,
                    collection,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 1024)?;

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ChildRef<'static>, ___E> for &'a ChildRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ChildRef {
                    name,
                    collection,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 1024)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 1024)?;

            ::fidl_next::Encode::encode(&self.collection, encoder_, collection, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ChildRef<'de>> for ChildRef {
        #[inline]
        fn from_wire(wire: crate::wire::ChildRef<'de>) -> Self {
            Self {
                name: ::fidl_next::FromWire::from_wire(wire.name),

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

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

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

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

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::CollectionRef<'static>, ___E> for CollectionRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CollectionRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CollectionRef {
                    name,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CollectionRef<'static>, ___E>
        for &'a CollectionRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CollectionRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CollectionRef {
                    name,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::CollectionRef<'de>> for CollectionRef {
        #[inline]
        fn from_wire(wire: crate::wire::CollectionRef<'de>) -> Self {
            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
        }
    }

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

    #[doc = " A reference to the component framework itself.\n"]
    pub type FrameworkRef = ();

    #[doc = " A reference to a capability declared in this component.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct CapabilityRef {
        pub name: ::std::string::String,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityRef<'static>, ___E> for CapabilityRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CapabilityRef {
                    name,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityRef<'static>, ___E>
        for &'a CapabilityRef
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CapabilityRef {
                    name,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityRef<'de>> for CapabilityRef {
        #[inline]
        fn from_wire(wire: crate::wire::CapabilityRef<'de>) -> Self {
            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
        }
    }

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

    #[doc = " A reference to the environment\'s debug capabilities.\n"]
    pub type DebugRef = ();

    #[doc = " A reference to an intentionally missing offer source.\n"]
    pub type VoidRef = ();

    #[doc = " Declares which identifier to use to key a component\'s isolated storage\n directory.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum StorageId {
        StaticInstanceId = 1,
        StaticInstanceIdOrMoniker = 2,
    }
    impl ::core::convert::TryFrom<u32> for StorageId {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                1 => Ok(Self::StaticInstanceId),
                2 => Ok(Self::StaticInstanceIdOrMoniker),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageId, ___E> for StorageId
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::StorageId>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StorageId, ___E> for &'a StorageId
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::StorageId>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::StorageId { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                StorageId::StaticInstanceId => 1,

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

            Ok(())
        }
    }

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

                2 => Self::StaticInstanceIdOrMoniker,

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

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

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

    #[doc = " Declares a runner capability backed by a service.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Runner {
        pub name: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Runner<'static>, ___E> for Runner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Runner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Runner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Runner<'static>, ___E> for &'a Runner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Runner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Runner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Runner<'de>> for Runner {
        #[inline]
        fn from_wire(wire_: crate::wire::Runner<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Resolver {
        pub name: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Resolver<'static>, ___E> for Resolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Resolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Resolver { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Resolver<'static>, ___E> for &'a Resolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Resolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Resolver { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Resolver<'de>> for Resolver {
        #[inline]
        fn from_wire(wire_: crate::wire::Resolver<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct EventStream {
        pub name: ::core::option::Option<::std::string::String>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::EventStream<'de>> for EventStream {
        #[inline]
        fn from_wire(wire_: crate::wire::EventStream<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

        Uint8(u8),

        Uint16(u16),

        Uint32(u32),

        Uint64(u64),

        Int8(i8),

        Int16(i16),

        Int32(i32),

        Int64(i64),

        String(::std::string::String),

        UnknownOrdinal_(u64),
    }

    impl ConfigSingleValue {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigSingleValue<'static>, ___E>
        for ConfigSingleValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSingleValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSingleValue { raw, _phantom: _ } = out);

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

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

                Self::Uint16(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint16,
                >(value, 3, encoder, raw, ())?,

                Self::Uint32(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint32,
                >(value, 4, encoder, raw, ())?,

                Self::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint64,
                >(value, 5, encoder, raw, ())?,

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

                Self::Int16(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int16,
                >(value, 7, encoder, raw, ())?,

                Self::Int32(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int32,
                >(value, 8, encoder, raw, ())?,

                Self::Int64(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int64,
                >(value, 9, encoder, raw, ())?,

                Self::String(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::String<'static>,
                >(value, 10, encoder, raw, 4294967295)?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigSingleValue<'static>, ___E>
        for &'a ConfigSingleValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSingleValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSingleValue { raw, _phantom: _ } = out);

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

                ConfigSingleValue::Uint8(value) => {
                    ::fidl_next::wire::Union::encode_as::<___E, u8>(value, 2, encoder, raw, ())?
                }

                ConfigSingleValue::Uint16(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint16,
                >(value, 3, encoder, raw, ())?,

                ConfigSingleValue::Uint32(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint32,
                >(value, 4, encoder, raw, ())?,

                ConfigSingleValue::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint64,
                >(value, 5, encoder, raw, ())?,

                ConfigSingleValue::Int8(value) => {
                    ::fidl_next::wire::Union::encode_as::<___E, i8>(value, 6, encoder, raw, ())?
                }

                ConfigSingleValue::Int16(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int16,
                >(value, 7, encoder, raw, ())?,

                ConfigSingleValue::Int32(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int32,
                >(value, 8, encoder, raw, ())?,

                ConfigSingleValue::Int64(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Int64,
                >(value, 9, encoder, raw, ())?,

                ConfigSingleValue::String(value) => {
                    ::fidl_next::wire::Union::encode_as::<___E, ::fidl_next::wire::String<'static>>(
                        value, 10, encoder, raw, 4294967295,
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigSingleValue<'static>, ___E>
        for &'a ConfigSingleValue
    where
        ___E: ?Sized,
        &'a ConfigSingleValue: ::fidl_next::Encode<crate::wire::ConfigSingleValue<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigSingleValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigSingleValue { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigSingleValue<'de>>
        for ConfigSingleValue
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigSingleValue<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigSingleValue<'de>>
        for Box<ConfigSingleValue>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigSingleValue<'de>,
        ) -> ::core::option::Option<Self> {
            <ConfigSingleValue as ::fidl_next::FromWireOption<
                crate::wire_optional::ConfigSingleValue<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

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

    #[doc = " A vector configuration value.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum ConfigVectorValue {
        BoolVector(::std::vec::Vec<bool>),

        Uint8Vector(::std::vec::Vec<u8>),

        Uint16Vector(::std::vec::Vec<u16>),

        Uint32Vector(::std::vec::Vec<u32>),

        Uint64Vector(::std::vec::Vec<u64>),

        Int8Vector(::std::vec::Vec<i8>),

        Int16Vector(::std::vec::Vec<i16>),

        Int32Vector(::std::vec::Vec<i32>),

        Int64Vector(::std::vec::Vec<i64>),

        StringVector(::std::vec::Vec<::std::string::String>),

        UnknownOrdinal_(u64),
    }

    impl ConfigVectorValue {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigVectorValue<'static>, ___E>
        for ConfigVectorValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigVectorValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigVectorValue { raw, _phantom: _ } = out);

            match self {
                Self::BoolVector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, bool>,
                    >(value, 1, encoder, raw, (4294967295, ()))?
                }

                Self::Uint8Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, u8>,
                    >(value, 2, encoder, raw, (4294967295, ()))?
                }

                Self::Uint16Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>,
                    >(value, 3, encoder, raw, (4294967295, ()))?
                }

                Self::Uint32Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint32>,
                    >(value, 4, encoder, raw, (4294967295, ()))?
                }

                Self::Uint64Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint64>,
                    >(value, 5, encoder, raw, (4294967295, ()))?
                }

                Self::Int8Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, i8>,
                    >(value, 6, encoder, raw, (4294967295, ()))?
                }

                Self::Int16Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int16>,
                    >(value, 7, encoder, raw, (4294967295, ()))?
                }

                Self::Int32Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int32>,
                    >(value, 8, encoder, raw, (4294967295, ()))?
                }

                Self::Int64Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int64>,
                    >(value, 9, encoder, raw, (4294967295, ()))?
                }

                Self::StringVector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
                    >(value, 10, encoder, raw, (4294967295, 4294967295))?
                }

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigVectorValue<'static>, ___E>
        for &'a ConfigVectorValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigVectorValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigVectorValue { raw, _phantom: _ } = out);

            match self {
                ConfigVectorValue::BoolVector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, bool>,
                    >(value, 1, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Uint8Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, u8>,
                    >(value, 2, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Uint16Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint16>,
                    >(value, 3, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Uint32Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint32>,
                    >(value, 4, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Uint64Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Uint64>,
                    >(value, 5, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Int8Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, i8>,
                    >(value, 6, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Int16Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int16>,
                    >(value, 7, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Int32Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int32>,
                    >(value, 8, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::Int64Vector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Int64>,
                    >(value, 9, encoder, raw, (4294967295, ()))?
                }

                ConfigVectorValue::StringVector(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
                    >(value, 10, encoder, raw, (4294967295, 4294967295))?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigVectorValue<'static>, ___E>
        for &'a ConfigVectorValue
    where
        ___E: ?Sized,
        &'a ConfigVectorValue: ::fidl_next::Encode<crate::wire::ConfigVectorValue<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigVectorValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigVectorValue { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigVectorValue<'de>>
        for ConfigVectorValue
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigVectorValue<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigVectorValue<'de>>
        for Box<ConfigVectorValue>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigVectorValue<'de>,
        ) -> ::core::option::Option<Self> {
            <ConfigVectorValue as ::fidl_next::FromWireOption<
                crate::wire_optional::ConfigVectorValue<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

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

    #[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(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum ConfigValue {
        Single(crate::natural::ConfigSingleValue),

        Vector(crate::natural::ConfigVectorValue),

        UnknownOrdinal_(u64),
    }

    impl ConfigValue {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigValue<'static>, ___E> for ConfigValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValue { raw, _phantom: _ } = out);

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

                Self::Vector(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigVectorValue<'static>,
                >(value, 2, encoder, raw, ())?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigValue<'static>, ___E>
        for &'a ConfigValue
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValue { raw, _phantom: _ } = out);

            match self {
                ConfigValue::Single(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigSingleValue<'static>,
                >(value, 1, encoder, raw, ())?,

                ConfigValue::Vector(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigVectorValue<'static>,
                >(value, 2, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigValue<'static>, ___E>
        for &'a ConfigValue
    where
        ___E: ?Sized,
        &'a ConfigValue: ::fidl_next::Encode<crate::wire::ConfigValue<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigValue<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigValue { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigValue<'de>> for ConfigValue {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigValue<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigValue<'de>> for Box<ConfigValue> {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigValue<'de>,
        ) -> ::core::option::Option<Self> {
            <
            ConfigValue as ::fidl_next::FromWireOption<crate::wire_optional::ConfigValue<'de>>
        >::from_wire_option(wire).map(Box::new)
        }
    }

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Configuration {
        pub name: ::core::option::Option<::std::string::String>,

        pub value: ::core::option::Option<crate::natural::ConfigValue>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Configuration<'static>, ___E> for Configuration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Configuration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Configuration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.value.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Configuration<'static>, ___E>
        for &'a Configuration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Configuration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Configuration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.value {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Configuration<'de>> for Configuration {
        #[inline]
        fn from_wire(wire_: crate::wire::Configuration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

    #[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 = ::std::string::String;

    #[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(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum DeliveryType {
        Immediate = 0,
        OnReadable = 1,
        UnknownOrdinal_(u32) = 2,
    }
    impl ::std::convert::From<u32> for DeliveryType {
        fn from(value: u32) -> Self {
            match value {
                0 => Self::Immediate,
                1 => Self::OnReadable,

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

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeliveryType, ___E> for DeliveryType
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DeliveryType>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeliveryType, ___E> for &'a DeliveryType
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DeliveryType>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DeliveryType { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                DeliveryType::Immediate => 0,

                DeliveryType::OnReadable => 1,

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

            Ok(())
        }
    }

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

                1 => Self::OnReadable,

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

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

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Protocol {
        pub name: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,

        pub delivery: ::core::option::Option<crate::natural::DeliveryType>,
    }

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

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

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

                    2 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

                    2 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Protocol<'de>> for Protocol {
        #[inline]
        fn from_wire(wire_: crate::wire::Protocol<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

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

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

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

    #[doc = " A reference to the environment.\n"]
    pub type EnvironmentRef = ();

    #[doc = " A reference to a capability source or destination relative to this\n component.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum Ref {
        Parent(crate::natural::ParentRef),

        Self_(crate::natural::SelfRef),

        Child(crate::natural::ChildRef),

        Collection(crate::natural::CollectionRef),

        Framework(crate::natural::FrameworkRef),

        Capability(crate::natural::CapabilityRef),

        Debug(crate::natural::DebugRef),

        VoidType(crate::natural::VoidRef),

        Environment(crate::natural::EnvironmentRef),

        UnknownOrdinal_(u64),
    }

    impl Ref {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Ref<'static>, ___E> for Ref
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Ref<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Ref { raw, _phantom: _ } = out);

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

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

                Self::Child(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ChildRef<'static>,
                >(value, 3, encoder, raw, ())?,

                Self::Collection(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::CollectionRef<'static>,
                >(value, 4, encoder, raw, ())?,

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

                Self::Capability(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::CapabilityRef<'static>,
                >(value, 6, encoder, raw, ())?,

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

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

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Ref<'static>, ___E> for &'a Ref
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Ref<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Ref { raw, _phantom: _ } = out);

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

                Ref::Self_(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::SelfRef,
                >(value, 2, encoder, raw, ())?,

                Ref::Child(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ChildRef<'static>,
                >(value, 3, encoder, raw, ())?,

                Ref::Collection(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::CollectionRef<'static>,
                >(value, 4, encoder, raw, ())?,

                Ref::Framework(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::FrameworkRef,
                >(value, 5, encoder, raw, ())?,

                Ref::Capability(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::CapabilityRef<'static>,
                >(value, 6, encoder, raw, ())?,

                Ref::Debug(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::DebugRef,
                >(value, 7, encoder, raw, ())?,

                Ref::VoidType(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::VoidRef,
                >(value, 8, encoder, raw, ())?,

                Ref::Environment(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::EnvironmentRef,
                >(value, 9, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Ref<'static>, ___E>
        for &'a Ref
    where
        ___E: ?Sized,
        &'a Ref: ::fidl_next::Encode<crate::wire::Ref<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Ref<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::Ref { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Ref<'de>> for Ref {
        #[inline]
        fn from_wire_option(wire: crate::wire_optional::Ref<'de>) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Ref<'de>> for Box<Ref> {
        #[inline]
        fn from_wire_option(wire: crate::wire_optional::Ref<'de>) -> ::core::option::Option<Self> {
            <Ref as ::fidl_next::FromWireOption<crate::wire_optional::Ref<'de>>>::from_wire_option(
                wire,
            )
            .map(Box::new)
        }
    }

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

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

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub backing_dir: ::core::option::Option<::std::string::String>,

        pub subdir: ::core::option::Option<::std::string::String>,

        pub storage_id: ::core::option::Option<crate::natural::StorageId>,
    }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Storage<'static>, ___E> for Storage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Storage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Storage { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = self.storage_id.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::StorageId,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.subdir.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.backing_dir.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Storage<'static>, ___E> for &'a Storage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Storage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Storage { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = &self.storage_id {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::StorageId,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.subdir {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.backing_dir {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Storage<'de>> for Storage {
        #[inline]
        fn from_wire(wire_: crate::wire::Storage<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[doc = " Declares a dictionary capability.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Dictionary {
        pub name: ::core::option::Option<::std::string::String>,

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,

        pub source_path: ::core::option::Option<::std::string::String>,
    }

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Dictionary<'static>, ___E> for Dictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Dictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Dictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    4 => {
                        if let Some(value) = self.source_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Dictionary<'static>, ___E> for &'a Dictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Dictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Dictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    4 => {
                        if let Some(value) = &self.source_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Dictionary<'de>> for Dictionary {
        #[inline]
        fn from_wire(wire_: crate::wire::Dictionary<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

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

            let source_dictionary = wire_.table.get(3);

            let source_path = wire_.table.get(4);

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

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

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

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

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

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

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

    #[doc = " Declares a capability defined by this component.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum Capability {
        Service(crate::natural::Service),

        Protocol(crate::natural::Protocol),

        Directory(crate::natural::Directory),

        Storage(crate::natural::Storage),

        Runner(crate::natural::Runner),

        Resolver(crate::natural::Resolver),

        EventStream(crate::natural::EventStream),

        Dictionary(crate::natural::Dictionary),

        Config(crate::natural::Configuration),

        UnknownOrdinal_(u64),
    }

    impl Capability {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability<'static>, ___E> for Capability
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Capability<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);

            match self {
                Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Service<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Protocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Directory<'static>,
                >(value, 3, encoder, raw, ())?,

                Self::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Storage<'static>,
                >(value, 4, encoder, raw, ())?,

                Self::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Runner<'static>,
                >(value, 5, encoder, raw, ())?,

                Self::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Resolver<'static>,
                >(value, 6, encoder, raw, ())?,

                Self::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::EventStream<'static>,
                >(value, 8, encoder, raw, ())?,

                Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Dictionary<'static>,
                >(value, 9, encoder, raw, ())?,

                Self::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Configuration<'static>,
                >(value, 10, encoder, raw, ())?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Capability<'static>, ___E> for &'a Capability
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Capability<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);

            match self {
                Capability::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Service<'static>,
                >(value, 1, encoder, raw, ())?,

                Capability::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Protocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Capability::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Directory<'static>,
                >(value, 3, encoder, raw, ())?,

                Capability::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Storage<'static>,
                >(value, 4, encoder, raw, ())?,

                Capability::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Runner<'static>,
                >(value, 5, encoder, raw, ())?,

                Capability::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Resolver<'static>,
                >(value, 6, encoder, raw, ())?,

                Capability::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::EventStream<'static>,
                >(value, 8, encoder, raw, ())?,

                Capability::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Dictionary<'static>,
                >(value, 9, encoder, raw, ())?,

                Capability::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::Configuration<'static>,
                >(value, 10, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

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

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

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

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

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::Capability<'de>,
        ) -> ::core::option::Option<Self> {
            <
            Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
        >::from_wire_option(wire).map(Box::new)
        }
    }

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

    #[doc = " Describes under what conditions the component may be started.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum StartupMode {
        Lazy = 0,
        Eager = 1,
    }
    impl ::core::convert::TryFrom<u32> for StartupMode {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                0 => Ok(Self::Lazy),
                1 => Ok(Self::Eager),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartupMode, ___E> for StartupMode
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::StartupMode>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StartupMode, ___E> for &'a StartupMode
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::StartupMode>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::StartupMode { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                StartupMode::Lazy => 0,

                StartupMode::Eager => 1,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::StartupMode> for StartupMode {
        fn from(wire: crate::wire::StartupMode) -> Self {
            match u32::from(wire.value) {
                0 => Self::Lazy,

                1 => Self::Eager,

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

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

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

    #[doc = " Describes the action to take if this component instance terminates\n unexpectedly.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum OnTerminate {
        None = 0,
        Reboot = 1,
    }
    impl ::core::convert::TryFrom<u32> for OnTerminate {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                0 => Ok(Self::None),
                1 => Ok(Self::Reboot),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OnTerminate, ___E> for OnTerminate
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OnTerminate>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OnTerminate, ___E> for &'a OnTerminate
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OnTerminate>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OnTerminate { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                OnTerminate::None => 0,

                OnTerminate::Reboot => 1,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::OnTerminate> for OnTerminate {
        fn from(wire: crate::wire::OnTerminate) -> Self {
            match u32::from(wire.value) {
                0 => Self::None,

                1 => Self::Reboot,

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

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

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

    #[doc = " The string identifier for a config field.\n"]
    pub type ConfigKey = ::std::string::String;

    #[doc = " A directive to override the value of a particular configuration field in the child.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigOverride {
        pub key: ::core::option::Option<::std::string::String>,

        pub value: ::core::option::Option<crate::natural::ConfigValue>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigOverride<'static>, ___E> for ConfigOverride
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigOverride<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigOverride { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.value.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.key.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 64
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigOverride<'static>, ___E>
        for &'a ConfigOverride
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigOverride<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigOverride { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.value {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.key {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 64
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigOverride<'de>> for ConfigOverride {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigOverride<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let key = wire_.table.get(1);

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

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

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

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

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

    #[doc = " Statically declares a child component instance.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Child {
        pub name: ::core::option::Option<::std::string::String>,

        pub url: ::core::option::Option<::std::string::String>,

        pub startup: ::core::option::Option<crate::natural::StartupMode>,

        pub environment: ::core::option::Option<::std::string::String>,

        pub on_terminate: ::core::option::Option<crate::natural::OnTerminate>,

        pub config_overrides:
            ::core::option::Option<::std::vec::Vec<crate::natural::ConfigOverride>>,
    }

    impl Child {
        fn __max_ordinal(&self) -> usize {
            if self.config_overrides.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Child<'static>, ___E> for Child
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Child<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Child { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.config_overrides.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigOverride<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.on_terminate.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::OnTerminate,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.environment.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.startup.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::StartupMode,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.url.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 4096
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Child<'static>, ___E> for &'a Child
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Child<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Child { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.config_overrides {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigOverride<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.on_terminate {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::OnTerminate,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.environment {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.startup {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::StartupMode,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.url {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 4096
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Child<'de>> for Child {
        #[inline]
        fn from_wire(wire_: crate::wire::Child<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

            let url = wire_.table.get(2);

            let startup = wire_.table.get(3);

            let environment = wire_.table.get(4);

            let on_terminate = wire_.table.get(5);

            let config_overrides = wire_.table.get(6);

            Self {


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


                url: url.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                startup: startup.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::StartupMode>() }
                )),


                environment: environment.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                on_terminate: on_terminate.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::OnTerminate>() }
                )),


                config_overrides: config_overrides.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigOverride<'de>>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::Child<'de>> for Child {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::Child<'de>) -> Self {
            Self {


                name: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


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


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


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


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


                config_overrides: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigOverride<'de>>>() }
                    )),

        }
        }
    }

    #[doc = " The durability of component instances created in a collection.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum Durability {
        Transient = 2,
        SingleRun = 3,
    }
    impl ::core::convert::TryFrom<u32> for Durability {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                2 => Ok(Self::Transient),
                3 => Ok(Self::SingleRun),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Durability, ___E> for Durability
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Durability>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Durability, ___E> for &'a Durability
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Durability>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Durability { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                Durability::Transient => 2,

                Durability::SingleRun => 3,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::Durability> for Durability {
        fn from(wire: crate::wire::Durability) -> Self {
            match u32::from(wire.value) {
                2 => Self::Transient,

                3 => Self::SingleRun,

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

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

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

    #[doc = " Statically declares a component instance collection.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Collection {
        pub name: ::core::option::Option<::std::string::String>,

        pub durability: ::core::option::Option<crate::natural::Durability>,

        pub environment: ::core::option::Option<::std::string::String>,

        pub allowed_offers: ::core::option::Option<crate::natural::AllowedOffers>,

        pub allow_long_names: ::core::option::Option<bool>,

        pub persistent_storage: ::core::option::Option<bool>,
    }

    impl Collection {
        fn __max_ordinal(&self) -> usize {
            if self.persistent_storage.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Collection<'static>, ___E> for Collection
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Collection<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Collection { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.persistent_storage.take() {
                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.allow_long_names.take() {
                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.allowed_offers.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::AllowedOffers,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.environment.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.durability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Durability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Collection<'static>, ___E> for &'a Collection
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Collection<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Collection { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.persistent_storage {
                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.allow_long_names {
                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.allowed_offers {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::AllowedOffers,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.environment {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.durability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Durability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Collection<'de>> for Collection {
        #[inline]
        fn from_wire(wire_: crate::wire::Collection<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

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

            let durability = wire_.table.get(2);

            let environment = wire_.table.get(3);

            let allowed_offers = wire_.table.get(4);

            let allow_long_names = wire_.table.get(5);

            let persistent_storage = wire_.table.get(6);

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

                durability: durability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Durability>()
                    })
                }),

                environment: environment.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                allowed_offers: allowed_offers.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::AllowedOffers>()
                    })
                }),

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

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

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

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

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

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

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

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

    #[doc = " Describes the type of dependency implied by the capability.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum DependencyType {
        Strong = 1,
        Weak = 2,
    }
    impl ::core::convert::TryFrom<u32> for DependencyType {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                1 => Ok(Self::Strong),
                2 => Ok(Self::Weak),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DependencyType, ___E> for DependencyType
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DependencyType>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DependencyType, ___E> for &'a DependencyType
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DependencyType>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DependencyType { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                DependencyType::Strong => 1,

                DependencyType::Weak => 2,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::DependencyType> for DependencyType {
        fn from(wire: crate::wire::DependencyType) -> Self {
            match u32::from(wire.value) {
                1 => Self::Strong,

                2 => Self::Weak,

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

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

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

    #[doc = " Type used to create a mapping between 2 names. Used to rename service or component instances\n in FIDL declarations.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NameMapping {
        pub source_name: ::std::string::String,

        pub target_name: ::std::string::String,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NameMapping<'static>, ___E> for NameMapping
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::NameMapping<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::NameMapping {
                    source_name,
                    target_name,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.source_name, encoder_, source_name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(source_name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            ::fidl_next::Encode::encode(self.target_name, encoder_, target_name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target_name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NameMapping<'static>, ___E>
        for &'a NameMapping
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::NameMapping<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::NameMapping {
                    source_name,
                    target_name,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.source_name, encoder_, source_name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(source_name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            ::fidl_next::Encode::encode(&self.target_name, encoder_, target_name, 100)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target_name.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 100)?;

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::NameMapping<'de>> for NameMapping {
        #[inline]
        fn from_wire(wire: crate::wire::NameMapping<'de>) -> Self {
            Self {
                source_name: ::fidl_next::FromWire::from_wire(wire.source_name),

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

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

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

    #[doc = " Specifies how a declared environment\'s initial set of properties are assigned.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum EnvironmentExtends {
        None = 0,
        Realm = 1,
    }
    impl ::core::convert::TryFrom<u32> for EnvironmentExtends {
        type Error = ::fidl_next::UnknownStrictEnumMemberError;
        fn try_from(
            value: u32,
        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
            match value {
                0 => Ok(Self::None),
                1 => Ok(Self::Realm),

                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::EnvironmentExtends, ___E> for EnvironmentExtends
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::EnvironmentExtends>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EnvironmentExtends, ___E>
        for &'a EnvironmentExtends
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::EnvironmentExtends>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::EnvironmentExtends { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                EnvironmentExtends::None => 0,

                EnvironmentExtends::Realm => 1,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::EnvironmentExtends> for EnvironmentExtends {
        fn from(wire: crate::wire::EnvironmentExtends) -> Self {
            match u32::from(wire.value) {
                0 => Self::None,

                1 => Self::Realm,

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

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

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

    pub type UrlScheme = ::std::string::String;

    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[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) = 12,
    }
    impl ::std::convert::From<u32> for ConfigTypeLayout {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::Bool,
                2 => Self::Uint8,
                3 => Self::Uint16,
                4 => Self::Uint32,
                5 => Self::Uint64,
                6 => Self::Int8,
                7 => Self::Int16,
                8 => Self::Int32,
                9 => Self::Int64,
                10 => Self::String,
                11 => Self::Vector,

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

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigTypeLayout, ___E> for ConfigTypeLayout
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigTypeLayout>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigTypeLayout, ___E>
        for &'a ConfigTypeLayout
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigTypeLayout>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigTypeLayout { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                ConfigTypeLayout::Bool => 1,

                ConfigTypeLayout::Uint8 => 2,

                ConfigTypeLayout::Uint16 => 3,

                ConfigTypeLayout::Uint32 => 4,

                ConfigTypeLayout::Uint64 => 5,

                ConfigTypeLayout::Int8 => 6,

                ConfigTypeLayout::Int16 => 7,

                ConfigTypeLayout::Int32 => 8,

                ConfigTypeLayout::Int64 => 9,

                ConfigTypeLayout::String => 10,

                ConfigTypeLayout::Vector => 11,

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

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::ConfigTypeLayout> for ConfigTypeLayout {
        fn from(wire: crate::wire::ConfigTypeLayout) -> Self {
            match u32::from(wire.value) {
                1 => Self::Bool,

                2 => Self::Uint8,

                3 => Self::Uint16,

                4 => Self::Uint32,

                5 => Self::Uint64,

                6 => Self::Int8,

                7 => Self::Int16,

                8 => Self::Int32,

                9 => Self::Int64,

                10 => Self::String,

                11 => Self::Vector,

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

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

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

    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum LayoutConstraint {
        MaxSize(u32),

        UnknownOrdinal_(u64),
    }

    impl LayoutConstraint {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::LayoutConstraint<'static>, ___E>
        for LayoutConstraint
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::LayoutConstraint<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::LayoutConstraint { raw, _phantom: _ } = out);

            match self {
                Self::MaxSize(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint32,
                >(value, 1, encoder, raw, ())?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::LayoutConstraint<'static>, ___E>
        for &'a LayoutConstraint
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::LayoutConstraint<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::LayoutConstraint { raw, _phantom: _ } = out);

            match self {
                LayoutConstraint::MaxSize(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::Uint32,
                >(value, 1, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::LayoutConstraint<'static>, ___E>
        for &'a LayoutConstraint
    where
        ___E: ?Sized,
        &'a LayoutConstraint: ::fidl_next::Encode<crate::wire::LayoutConstraint<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::LayoutConstraint<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::LayoutConstraint { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::LayoutConstraint<'de>>
        for LayoutConstraint
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::LayoutConstraint<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::LayoutConstraint<'de>>
        for Box<LayoutConstraint>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::LayoutConstraint<'de>,
        ) -> ::core::option::Option<Self> {
            <LayoutConstraint as ::fidl_next::FromWireOption<
                crate::wire_optional::LayoutConstraint<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

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

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigType {
        pub layout: crate::natural::ConfigTypeLayout,

        pub parameters: ::core::option::Option<::std::vec::Vec<crate::natural::LayoutParameter>>,

        pub constraints: ::std::vec::Vec<crate::natural::LayoutConstraint>,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigType<'static>, ___E> for ConfigType
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ConfigType<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ConfigType {
                    layout,
                    parameters,
                    constraints,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.layout, encoder_, layout, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(layout.as_mut_ptr()) };

            ::fidl_next::Encode::encode(self.parameters, encoder_, parameters, (4294967295, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(parameters.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            ::fidl_next::Encode::encode(self.constraints, encoder_, constraints, (4294967295, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(constraints.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigType<'static>, ___E> for &'a ConfigType
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ConfigType<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ConfigType {
                    layout,
                    parameters,
                    constraints,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(layout.as_mut_ptr()) };

            ::fidl_next::Encode::encode(&self.parameters, encoder_, parameters, (4294967295, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(parameters.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            ::fidl_next::Encode::encode(
                &self.constraints,
                encoder_,
                constraints,
                (4294967295, ()),
            )?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(constraints.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigType<'de>> for ConfigType {
        #[inline]
        fn from_wire(wire: crate::wire::ConfigType<'de>) -> Self {
            Self {
                layout: ::fidl_next::FromWire::from_wire(wire.layout),

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

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

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

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

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

    #[doc = " The checksum produced for a configuration interface.\n Two configuration interfaces are the same if their checksums are the same.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum ConfigChecksum {
        Sha256([u8; 32]),

        UnknownOrdinal_(u64),
    }

    impl ConfigChecksum {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigChecksum<'static>, ___E> for ConfigChecksum
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigChecksum<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigChecksum { raw, _phantom: _ } = out);

            match self {
                Self::Sha256(value) => ::fidl_next::wire::Union::encode_as::<___E, [u8; 32]>(
                    value,
                    1,
                    encoder,
                    raw,
                    (),
                )?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigChecksum<'static>, ___E>
        for &'a ConfigChecksum
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigChecksum<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigChecksum { raw, _phantom: _ } = out);

            match self {
                ConfigChecksum::Sha256(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    [u8; 32],
                >(value, 1, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigChecksum<'static>, ___E>
        for &'a ConfigChecksum
    where
        ___E: ?Sized,
        &'a ConfigChecksum: ::fidl_next::Encode<crate::wire::ConfigChecksum<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigChecksum<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigChecksum { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigChecksum<'de>> for ConfigChecksum {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigChecksum<'de>) -> Self {
            match wire.raw.ordinal() {
                1 => Self::Sha256(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<[u8; 32]>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigChecksum<'de>>
        for ConfigChecksum
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigChecksum<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigChecksum<'de>>
        for Box<ConfigChecksum>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigChecksum<'de>,
        ) -> ::core::option::Option<Self> {
            <ConfigChecksum as ::fidl_next::FromWireOption<
                crate::wire_optional::ConfigChecksum<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

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

    #[doc = " Declares storage used by a component, which was offered to it.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseStorage {
        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,
    }

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseStorage<'static>, ___E> for UseStorage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseStorage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseStorage { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseStorage<'static>, ___E> for &'a UseStorage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseStorage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseStorage { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseStorage<'de>> for UseStorage {
        #[inline]
        fn from_wire(wire_: crate::wire::UseStorage<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source_name = wire_.table.get(1);

            let target_path = wire_.table.get(2);

            let availability = wire_.table.get(3);

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

                target_path: target_path.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),
            }
        }
    }

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

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

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

    ::fidl_next::bitflags::bitflags! {
        #[doc = " Allowed sources for runtime overrides of a config field\'s value.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct ConfigMutability: u32 {
            #[doc = " Allow parent components to provide overrides for the configuration field.\n"]const PARENT = 1;
            const _ = !0;
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigMutability, ___E> for ConfigMutability
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigMutability>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigMutability, ___E>
        for &'a ConfigMutability
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            _: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigMutability>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigMutability { value } = out);

            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::ConfigMutability> for ConfigMutability {
        fn from(wire: crate::wire::ConfigMutability) -> Self {
            Self::from_bits_retain(u32::from(wire.value))
        }
    }

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

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

    #[doc = " Declares a single config field (key + type)\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigField {
        pub key: ::core::option::Option<::std::string::String>,

        pub type_: ::core::option::Option<crate::natural::ConfigType>,

        pub mutability: ::core::option::Option<crate::natural::ConfigMutability>,
    }

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigField<'static>, ___E> for ConfigField
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigField<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigField { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.mutability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigMutability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.type_.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigType<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.key.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 64
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigField<'static>, ___E>
        for &'a ConfigField
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigField<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigField { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.mutability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigMutability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.type_ {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigType<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.key {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 64
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigField<'de>> for ConfigField {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigField<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let key = wire_.table.get(1);

            let type_ = wire_.table.get(2);

            let mutability = wire_.table.get(3);

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

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

                mutability: mutability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::ConfigMutability>()
                    })
                }),
            }
        }
    }

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

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

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

    #[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(Debug, Default, Clone, PartialEq)]
    pub struct Program {
        pub runner: ::core::option::Option<::std::string::String>,

        pub info: ::core::option::Option<::fidl_next_common_fuchsia_data::natural::Dictionary>,
    }

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Program<'static>, ___E> for Program
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Program<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Program { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.info.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.runner.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Program<'static>, ___E> for &'a Program
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Program<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Program { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.info {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.runner {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Program<'de>> for Program {
        #[inline]
        fn from_wire(wire_: crate::wire::Program<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let runner = wire_.table.get(1);

            let info = wire_.table.get(2);

            Self {


                runner: runner.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                info: info.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::Program<'de>> for Program {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::Program<'de>) -> Self {
            Self {


                runner: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


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

        }
        }
    }

    #[doc = " Debug information about the component.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct DebugInfo {
        pub manifest_sources: ::core::option::Option<::std::vec::Vec<::std::string::String>>,
    }

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugInfo<'static>, ___E> for DebugInfo
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugInfo<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugInfo { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = self.manifest_sources.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    ::fidl_next::wire::String<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, 4294967295)
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugInfo<'static>, ___E> for &'a DebugInfo
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugInfo<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugInfo { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = &self.manifest_sources {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    ::fidl_next::wire::String<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, 4294967295)
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::DebugInfo<'de>> for DebugInfo {
        #[inline]
        fn from_wire(wire_: crate::wire::DebugInfo<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let manifest_sources = wire_.table.get(1);

            Self {


                manifest_sources: manifest_sources.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugInfo<'de>> for DebugInfo {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::DebugInfo<'de>) -> Self {
            Self {


                manifest_sources: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>() }
                    )),

        }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseService {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl UseService {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseService<'static>, ___E> for UseService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseService<'static>, ___E> for &'a UseService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseService<'de>> for UseService {
        #[inline]
        fn from_wire(wire_: crate::wire::UseService<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_path = wire_.table.get(3);

            let dependency_type = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_path: target_path.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseProtocol {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,

        pub numbered_handle: ::core::option::Option<u8>,
    }

    impl UseProtocol {
        fn __max_ordinal(&self) -> usize {
            if self.numbered_handle.is_some() {
                return 7;
            }

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseProtocol<'static>, ___E> for UseProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = self.numbered_handle.take() {
                            ::fidl_next::wire::Envelope::encode_value::<u8, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseProtocol<'static>, ___E>
        for &'a UseProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = &self.numbered_handle {
                            ::fidl_next::wire::Envelope::encode_value::<u8, ___E>(
                                value,
                                preallocated.encoder,
                                &mut out,
                                (),
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseProtocol<'de>> for UseProtocol {
        #[inline]
        fn from_wire(wire_: crate::wire::UseProtocol<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_path = wire_.table.get(3);

            let dependency_type = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

            let numbered_handle = wire_.table.get(7);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_path: target_path.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

    #[doc = " Declares a directory used by a component, which was offered to it.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseDirectory {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub rights: ::core::option::Option<::fidl_next_common_fuchsia_io::natural::Operations>,

        pub subdir: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl UseDirectory {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 8;
            }

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

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseDirectory<'static>, ___E> for UseDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseDirectory { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.subdir.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.rights.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseDirectory<'static>, ___E>
        for &'a UseDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseDirectory { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.subdir {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.rights {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseDirectory<'de>> for UseDirectory {
        #[inline]
        fn from_wire(wire_: crate::wire::UseDirectory<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_path = wire_.table.get(3);

            let rights = wire_.table.get(4);

            let subdir = wire_.table.get(5);

            let dependency_type = wire_.table.get(6);

            let availability = wire_.table.get(7);

            let source_dictionary = wire_.table.get(8);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_path: target_path.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                rights: rights.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
                    })
                }),

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

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

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

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

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

    #[doc = " Declares an EventStream used by a component.\n"]
    #[derive(Debug, Default, Clone, PartialEq)]
    pub struct UseEventStream {
        pub source_name: ::core::option::Option<::std::string::String>,

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub scope: ::core::option::Option<::std::vec::Vec<crate::natural::Ref>>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub filter: ::core::option::Option<::fidl_next_common_fuchsia_data::natural::Dictionary>,
    }

    impl UseEventStream {
        fn __max_ordinal(&self) -> usize {
            if self.filter.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseEventStream<'static>, ___E> for UseEventStream
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseEventStream<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseEventStream { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.filter.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.scope.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Ref<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseEventStream<'static>, ___E>
        for &'a UseEventStream
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseEventStream<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseEventStream { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.filter {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.scope {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Ref<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseEventStream<'de>> for UseEventStream {
        #[inline]
        fn from_wire(wire_: crate::wire::UseEventStream<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source_name = wire_.table.get(1);

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

            let scope = wire_.table.get(3);

            let target_path = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let filter = wire_.table.get(6);

            Self {


                source_name: source_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


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


                scope: scope.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>() }
                )),


                target_path: target_path.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                availability: availability.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Availability>() }
                )),


                filter: filter.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::UseEventStream<'de>> for UseEventStream {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::UseEventStream<'de>) -> Self {
            Self {


                source_name: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


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


                scope: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>() }
                    )),


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


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


                filter: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>() }
                    )),

        }
        }
    }

    #[doc = " Declares runner used by a component.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseRunner {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseRunner<'static>, ___E> for UseRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseRunner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseRunner<'static>, ___E> for &'a UseRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseRunner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseRunner<'de>> for UseRunner {
        #[inline]
        fn from_wire(wire_: crate::wire::UseRunner<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let source_dictionary = wire_.table.get(3);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseConfiguration {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub type_: ::core::option::Option<crate::natural::ConfigType>,

        pub default: ::core::option::Option<crate::natural::ConfigValue>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl UseConfiguration {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 7;
            }

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseConfiguration<'static>, ___E>
        for UseConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.default.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.type_.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigType<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseConfiguration<'static>, ___E>
        for &'a UseConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.default {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.type_ {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigType<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseConfiguration<'de>> for UseConfiguration {
        #[inline]
        fn from_wire(wire_: crate::wire::UseConfiguration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_name = wire_.table.get(3);

            let availability = wire_.table.get(4);

            let type_ = wire_.table.get(5);

            let default = wire_.table.get(6);

            let source_dictionary = wire_.table.get(7);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

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

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

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

                type_: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::ConfigType<'de>>()
                    })
                }),

                default: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::ConfigValue<'de>>()
                    })
                }),

                source_dictionary: wire.table.get(7).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct UseDictionary {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_path: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl UseDictionary {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 8;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UseDictionary<'static>, ___E> for UseDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseDictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target_path.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UseDictionary<'static>, ___E>
        for &'a UseDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::UseDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UseDictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target_path {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::UseDictionary<'de>> for UseDictionary {
        #[inline]
        fn from_wire(wire_: crate::wire::UseDictionary<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_path = wire_.table.get(3);

            let dependency_type = wire_.table.get(6);

            let availability = wire_.table.get(7);

            let source_dictionary = wire_.table.get(8);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_path: target_path.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

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

    #[doc = " Declares a capability used by a component, which was offered to it.\n"]
    #[derive(Debug, Clone, PartialEq)]
    pub enum Use {
        Service(crate::natural::UseService),

        Protocol(crate::natural::UseProtocol),

        Directory(crate::natural::UseDirectory),

        Storage(crate::natural::UseStorage),

        EventStream(crate::natural::UseEventStream),

        Runner(crate::natural::UseRunner),

        Config(crate::natural::UseConfiguration),

        Dictionary(crate::natural::UseDictionary),

        UnknownOrdinal_(u64),
    }

    impl Use {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Use<'static>, ___E> for Use
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Use<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Use { raw, _phantom: _ } = out);

            match self {
                Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseService<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Self::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseStorage<'static>,
                >(value, 4, encoder, raw, ())?,

                Self::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseEventStream<'static>,
                >(value, 7, encoder, raw, ())?,

                Self::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseRunner<'static>,
                >(value, 8, encoder, raw, ())?,

                Self::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseConfiguration<'static>,
                >(value, 9, encoder, raw, ())?,

                Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseDictionary<'static>,
                >(value, 10, encoder, raw, ())?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Use<'static>, ___E> for &'a Use
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Use<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Use { raw, _phantom: _ } = out);

            match self {
                Use::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseService<'static>,
                >(value, 1, encoder, raw, ())?,

                Use::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Use::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Use::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseStorage<'static>,
                >(value, 4, encoder, raw, ())?,

                Use::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseEventStream<'static>,
                >(value, 7, encoder, raw, ())?,

                Use::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseRunner<'static>,
                >(value, 8, encoder, raw, ())?,

                Use::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseConfiguration<'static>,
                >(value, 9, encoder, raw, ())?,

                Use::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::UseDictionary<'static>,
                >(value, 10, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Use<'static>, ___E>
        for &'a Use
    where
        ___E: ?Sized,
        &'a Use: ::fidl_next::Encode<crate::wire::Use<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Use<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::Use { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

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

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

                7 => Self::EventStream(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::UseEventStream<'de>>()
                })),

                8 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::UseRunner<'de>>()
                })),

                9 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::UseConfiguration<'de>>()
                })),

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

                7 => Self::EventStream(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::UseEventStream<'de>>()
                })),

                8 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::UseRunner<'de>>()
                })),

                9 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::UseConfiguration<'de>>()
                })),

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

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Use<'de>> for Use {
        #[inline]
        fn from_wire_option(wire: crate::wire_optional::Use<'de>) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Use<'de>> for Box<Use> {
        #[inline]
        fn from_wire_option(wire: crate::wire_optional::Use<'de>) -> ::core::option::Option<Self> {
            <Use as ::fidl_next::FromWireOption<crate::wire_optional::Use<'de>>>::from_wire_option(
                wire,
            )
            .map(Box::new)
        }
    }

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeService {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeService {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeService<'static>, ___E> for ExposeService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeService<'static>, ___E>
        for &'a ExposeService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeService<'de>> for ExposeService {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeService<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeProtocol {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeProtocol {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeProtocol<'static>, ___E> for ExposeProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeProtocol<'static>, ___E>
        for &'a ExposeProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeProtocol<'de>> for ExposeProtocol {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeProtocol<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeDirectory {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub rights: ::core::option::Option<::fidl_next_common_fuchsia_io::natural::Operations>,

        pub subdir: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeDirectory {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 8;
            }

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

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeDirectory<'static>, ___E>
        for ExposeDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeDirectory { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.subdir.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.rights.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeDirectory<'static>, ___E>
        for &'a ExposeDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeDirectory { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    8 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.subdir {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.rights {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeDirectory<'de>> for ExposeDirectory {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeDirectory<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let rights = wire_.table.get(5);

            let subdir = wire_.table.get(6);

            let availability = wire_.table.get(7);

            let source_dictionary = wire_.table.get(8);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                rights: rights.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
                    })
                }),

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

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

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

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

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeRunner {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeRunner {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeRunner<'static>, ___E> for ExposeRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeRunner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeRunner<'static>, ___E>
        for &'a ExposeRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeRunner { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeRunner<'de>> for ExposeRunner {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeRunner<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeResolver {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeResolver {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeResolver<'static>, ___E> for ExposeResolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeResolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeResolver { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeResolver<'static>, ___E>
        for &'a ExposeResolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeResolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeResolver { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeResolver<'de>> for ExposeResolver {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeResolver<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeDictionary {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeDictionary {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeDictionary<'static>, ___E>
        for ExposeDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeDictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeDictionary<'static>, ___E>
        for &'a ExposeDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeDictionary { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeDictionary<'de>> for ExposeDictionary {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeDictionary<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ExposeConfiguration {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl ExposeConfiguration {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExposeConfiguration<'static>, ___E>
        for ExposeConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExposeConfiguration<'static>, ___E>
        for &'a ExposeConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExposeConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExposeConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ExposeConfiguration<'de>> for ExposeConfiguration {
        #[inline]
        fn from_wire(wire_: crate::wire::ExposeConfiguration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum Expose {
        Service(crate::natural::ExposeService),

        Protocol(crate::natural::ExposeProtocol),

        Directory(crate::natural::ExposeDirectory),

        Runner(crate::natural::ExposeRunner),

        Resolver(crate::natural::ExposeResolver),

        Dictionary(crate::natural::ExposeDictionary),

        Config(crate::natural::ExposeConfiguration),

        UnknownOrdinal_(u64),
    }

    impl Expose {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Expose<'static>, ___E> for Expose
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Expose<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Expose { raw, _phantom: _ } = out);

            match self {
                Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeService<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Self::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeRunner<'static>,
                >(value, 4, encoder, raw, ())?,

                Self::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeResolver<'static>,
                >(value, 5, encoder, raw, ())?,

                Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeDictionary<'static>,
                >(value, 7, encoder, raw, ())?,

                Self::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeConfiguration<'static>,
                >(value, 8, encoder, raw, ())?,

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Expose<'static>, ___E> for &'a Expose
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Expose<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Expose { raw, _phantom: _ } = out);

            match self {
                Expose::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeService<'static>,
                >(value, 1, encoder, raw, ())?,

                Expose::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Expose::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Expose::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeRunner<'static>,
                >(value, 4, encoder, raw, ())?,

                Expose::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeResolver<'static>,
                >(value, 5, encoder, raw, ())?,

                Expose::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeDictionary<'static>,
                >(value, 7, encoder, raw, ())?,

                Expose::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ExposeConfiguration<'static>,
                >(value, 8, encoder, raw, ())?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Expose<'static>, ___E>
        for &'a Expose
    where
        ___E: ?Sized,
        &'a Expose: ::fidl_next::Encode<crate::wire::Expose<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Expose<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::Expose { raw, _phantom: _ } = &mut *out);

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

            Ok(())
        }
    }

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

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

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

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

                5 => Self::Resolver(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::ExposeResolver<'de>>()
                })),

                7 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::ExposeDictionary<'de>>()
                })),

                8 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::ExposeConfiguration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

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

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

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

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

                5 => Self::Resolver(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::ExposeResolver<'de>>()
                })),

                7 => Self::Dictionary(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::ExposeDictionary<'de>>()
                })),

                8 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::ExposeConfiguration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Expose<'de>> for Expose {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::Expose<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Expose<'de>> for Box<Expose> {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::Expose<'de>,
        ) -> ::core::option::Option<Self> {
            <
            Expose as ::fidl_next::FromWireOption<crate::wire_optional::Expose<'de>>
        >::from_wire_option(wire).map(Box::new)
        }
    }

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

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferService {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub source_instance_filter: ::core::option::Option<::std::vec::Vec<::std::string::String>>,

        pub renamed_instances: ::core::option::Option<::std::vec::Vec<crate::natural::NameMapping>>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,
    }

    impl OfferService {
        fn __max_ordinal(&self) -> usize {
            if self.dependency_type.is_some() {
                return 9;
            }

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

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

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferService<'static>, ___E> for OfferService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    9 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.renamed_instances.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::NameMapping<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.source_instance_filter.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    ::fidl_next::wire::String<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, 100)
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferService<'static>, ___E>
        for &'a OfferService
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferService<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferService { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    9 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.renamed_instances {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::NameMapping<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.source_instance_filter {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    ::fidl_next::wire::String<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, 100)
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferService<'de>> for OfferService {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferService<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let source_instance_filter = wire_.table.get(5);

            let renamed_instances = wire_.table.get(6);

            let availability = wire_.table.get(7);

            let source_dictionary = wire_.table.get(8);

            let dependency_type = wire_.table.get(9);

            Self {


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


                source_name: source_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


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


                target_name: target_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                source_instance_filter: source_instance_filter.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>() }
                )),


                renamed_instances: renamed_instances.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NameMapping<'de>>>() }
                )),


                availability: availability.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Availability>() }
                )),


                source_dictionary: source_dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                dependency_type: dependency_type.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::DependencyType>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferService<'de>> for OfferService {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferService<'de>) -> Self {
            Self {


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


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


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


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


                source_instance_filter: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>() }
                    )),


                renamed_instances: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NameMapping<'de>>>() }
                    )),


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


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


                dependency_type: wire.table.get(9)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::DependencyType>() }
                    )),

        }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferProtocol {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferProtocol {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 7;
            }

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferProtocol<'static>, ___E> for OfferProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferProtocol<'static>, ___E>
        for &'a OfferProtocol
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferProtocol<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferProtocol { table } = out);

            let max_ord = self.__max_ordinal();

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

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

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

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

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferProtocol<'de>> for OfferProtocol {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferProtocol<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let dependency_type = wire_.table.get(5);

            let availability = wire_.table.get(6);

            let source_dictionary = wire_.table.get(7);

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

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

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

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

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

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

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

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

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

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

                source_dictionary: wire.table.get(7).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferDirectory {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub rights: ::core::option::Option<::fidl_next_common_fuchsia_io::natural::Operations>,

        pub subdir: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferDirectory {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 9;
            }

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

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

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

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

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

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

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

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

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferDirectory<'static>, ___E> for OfferDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferDirectory { table } = out);

            let max_ord = self.__max_ordinal();

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

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    9 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.subdir.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.rights.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferDirectory<'static>, ___E>
        for &'a OfferDirectory
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferDirectory<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferDirectory { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    9 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.subdir {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.rights {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_io::wire::Operations,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferDirectory<'de>> for OfferDirectory {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferDirectory<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let rights = wire_.table.get(5);

            let subdir = wire_.table.get(6);

            let dependency_type = wire_.table.get(7);

            let availability = wire_.table.get(8);

            let source_dictionary = wire_.table.get(9);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                rights: rights.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
                    })
                }),

                subdir: subdir.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferDirectory<'de>> for OfferDirectory {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferDirectory<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                rights: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope
                            .deref_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
                    })
                }),

                subdir: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: wire.table.get(7).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: wire.table.get(8).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: wire.table.get(9).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferStorage {
        pub source_name: ::core::option::Option<::std::string::String>,

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,
    }

    impl OfferStorage {
        fn __max_ordinal(&self) -> usize {
            if self.availability.is_some() {
                return 5;
            }

            if self.target_name.is_some() {
                return 4;
            }

            if self.target.is_some() {
                return 3;
            }

            if self.source.is_some() {
                return 2;
            }

            if self.source_name.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferStorage<'static>, ___E> for OfferStorage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferStorage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferStorage { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferStorage<'static>, ___E>
        for &'a OfferStorage
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferStorage<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferStorage { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferStorage<'de>> for OfferStorage {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferStorage<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source_name = wire_.table.get(1);

            let source = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            Self {
                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferStorage<'de>> for OfferStorage {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferStorage<'de>) -> Self {
            Self {
                source_name: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Availability>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferRunner {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferRunner {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 5;
            }

            if self.target_name.is_some() {
                return 4;
            }

            if self.target.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferRunner<'static>, ___E> for OfferRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferRunner { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferRunner<'static>, ___E>
        for &'a OfferRunner
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferRunner<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferRunner { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferRunner<'de>> for OfferRunner {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferRunner<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let source_dictionary = wire_.table.get(5);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferRunner<'de>> for OfferRunner {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferRunner<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferResolver {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferResolver {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 5;
            }

            if self.target_name.is_some() {
                return 4;
            }

            if self.target.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferResolver<'static>, ___E> for OfferResolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferResolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferResolver { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferResolver<'static>, ___E>
        for &'a OfferResolver
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferResolver<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferResolver { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    5 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferResolver<'de>> for OfferResolver {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferResolver<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let source_dictionary = wire_.table.get(5);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferResolver<'de>> for OfferResolver {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferResolver<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source_dictionary: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[doc = " Declares an event stream offered by a component.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferEventStream {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub scope: ::core::option::Option<::std::vec::Vec<crate::natural::Ref>>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,
    }

    impl OfferEventStream {
        fn __max_ordinal(&self) -> usize {
            if self.availability.is_some() {
                return 7;
            }

            if self.target_name.is_some() {
                return 5;
            }

            if self.target.is_some() {
                return 4;
            }

            if self.scope.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferEventStream<'static>, ___E>
        for OfferEventStream
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferEventStream<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferEventStream { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.scope.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Ref<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferEventStream<'static>, ___E>
        for &'a OfferEventStream
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferEventStream<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferEventStream { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.scope {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Ref<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferEventStream<'de>> for OfferEventStream {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferEventStream<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let scope = wire_.table.get(3);

            let target = wire_.table.get(4);

            let target_name = wire_.table.get(5);

            let availability = wire_.table.get(7);

            Self {


                source: source.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() }
                )),


                source_name: source_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                scope: scope.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>() }
                )),


                target: target.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() }
                )),


                target_name: target_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                availability: availability.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Availability>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferEventStream<'de>> for OfferEventStream {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferEventStream<'de>) -> Self {
            Self {


                source: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::Ref<'de>>() }
                    )),


                source_name: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


                scope: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>() }
                    )),


                target: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::Ref<'de>>() }
                    )),


                target_name: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


                availability: wire.table.get(7)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::Availability>() }
                    )),

        }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferDictionary {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub dependency_type: ::core::option::Option<crate::natural::DependencyType>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferDictionary {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 7;
            }

            if self.availability.is_some() {
                return 6;
            }

            if self.dependency_type.is_some() {
                return 5;
            }

            if self.target_name.is_some() {
                return 4;
            }

            if self.target.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferDictionary<'static>, ___E>
        for OfferDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferDictionary { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.dependency_type.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferDictionary<'static>, ___E>
        for &'a OfferDictionary
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferDictionary<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferDictionary { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    7 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.dependency_type {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DependencyType,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferDictionary<'de>> for OfferDictionary {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferDictionary<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let dependency_type = wire_.table.get(5);

            let availability = wire_.table.get(6);

            let source_dictionary = wire_.table.get(7);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: dependency_type.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferDictionary<'de>> for OfferDictionary {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferDictionary<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                dependency_type: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::DependencyType>()
                    })
                }),

                availability: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: wire.table.get(7).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OfferConfiguration {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,

        pub availability: ::core::option::Option<crate::natural::Availability>,

        pub source_dictionary: ::core::option::Option<::std::string::String>,
    }

    impl OfferConfiguration {
        fn __max_ordinal(&self) -> usize {
            if self.source_dictionary.is_some() {
                return 6;
            }

            if self.availability.is_some() {
                return 5;
            }

            if self.target_name.is_some() {
                return 4;
            }

            if self.target.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OfferConfiguration<'static>, ___E>
        for OfferConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.source_dictionary.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.availability.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.target.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OfferConfiguration<'static>, ___E>
        for &'a OfferConfiguration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::OfferConfiguration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::OfferConfiguration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.source_dictionary {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 1024
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.availability {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Availability,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.target {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::OfferConfiguration<'de>> for OfferConfiguration {
        #[inline]
        fn from_wire(wire_: crate::wire::OfferConfiguration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target = wire_.table.get(3);

            let target_name = wire_.table.get(4);

            let availability = wire_.table.get(5);

            let source_dictionary = wire_.table.get(6);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: target.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: availability.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: source_dictionary.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::OfferConfiguration<'de>> for OfferConfiguration {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::OfferConfiguration<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(4).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                availability: wire.table.get(5).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Availability>()
                    })
                }),

                source_dictionary: wire.table.get(6).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum Offer {
        Service(crate::natural::OfferService),

        Protocol(crate::natural::OfferProtocol),

        Directory(crate::natural::OfferDirectory),

        Storage(crate::natural::OfferStorage),

        Runner(crate::natural::OfferRunner),

        Resolver(crate::natural::OfferResolver),

        EventStream(crate::natural::OfferEventStream),

        Dictionary(crate::natural::OfferDictionary),

        Config(crate::natural::OfferConfiguration),

        UnknownOrdinal_(u64),
    }

    impl Offer {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Offer<'static>, ___E> for Offer
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Offer<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Offer { raw, _phantom: _ } = out);

            match self {
                Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferService<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Self::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferStorage<'static>,
                >(value, 4, encoder, raw, ())?,

                Self::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferRunner<'static>,
                >(value, 5, encoder, raw, ())?,

                Self::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferResolver<'static>,
                >(value, 6, encoder, raw, ())?,

                Self::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferEventStream<'static>,
                >(value, 8, encoder, raw, ())?,

                Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferDictionary<'static>,
                >(value, 9, encoder, raw, ())?,

                Self::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferConfiguration<'static>,
                >(value, 10, encoder, raw, ())?,

                Self::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Offer<'static>, ___E> for &'a Offer
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Offer<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Offer { raw, _phantom: _ } = out);

            match self {
                Offer::Service(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferService<'static>,
                >(value, 1, encoder, raw, ())?,

                Offer::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferProtocol<'static>,
                >(value, 2, encoder, raw, ())?,

                Offer::Directory(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferDirectory<'static>,
                >(value, 3, encoder, raw, ())?,

                Offer::Storage(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferStorage<'static>,
                >(value, 4, encoder, raw, ())?,

                Offer::Runner(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferRunner<'static>,
                >(value, 5, encoder, raw, ())?,

                Offer::Resolver(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferResolver<'static>,
                >(value, 6, encoder, raw, ())?,

                Offer::EventStream(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferEventStream<'static>,
                >(value, 8, encoder, raw, ())?,

                Offer::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferDictionary<'static>,
                >(value, 9, encoder, raw, ())?,

                Offer::Config(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::OfferConfiguration<'static>,
                >(value, 10, encoder, raw, ())?,

                Offer::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Offer<'static>, ___E> for Offer
    where
        ___E: ?Sized,
        Offer: ::fidl_next::Encode<crate::wire::Offer<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Offer<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::Offer { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Offer<'static>, ___E>
        for &'a Offer
    where
        ___E: ?Sized,
        &'a Offer: ::fidl_next::Encode<crate::wire::Offer<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Offer<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::Offer { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Offer<'de>> for Offer {
        #[inline]
        fn from_wire(wire: crate::wire::Offer<'de>) -> Self {
            let wire = ::core::mem::ManuallyDrop::new(wire);
            match wire.raw.ordinal() {
                1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferService<'de>>()
                })),

                2 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferProtocol<'de>>()
                })),

                3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferDirectory<'de>>()
                })),

                4 => Self::Storage(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferStorage<'de>>()
                })),

                5 => Self::Runner(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferRunner<'de>>()
                })),

                6 => Self::Resolver(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferResolver<'de>>()
                })),

                8 => Self::EventStream(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferEventStream<'de>>()
                })),

                9 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferDictionary<'de>>()
                })),

                10 => Self::Config(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::OfferConfiguration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::Offer<'de>> for Offer {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::Offer<'de>) -> Self {
            match wire.raw.ordinal() {
                1 => Self::Service(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferService<'de>>()
                })),

                2 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferProtocol<'de>>()
                })),

                3 => Self::Directory(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferDirectory<'de>>()
                })),

                4 => Self::Storage(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferStorage<'de>>()
                })),

                5 => Self::Runner(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferRunner<'de>>()
                })),

                6 => Self::Resolver(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferResolver<'de>>()
                })),

                8 => Self::EventStream(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferEventStream<'de>>()
                })),

                9 => Self::Dictionary(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferDictionary<'de>>()
                })),

                10 => Self::Config(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::OfferConfiguration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Offer<'de>> for Offer {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::Offer<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Offer<'de>> for Box<Offer> {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::Offer<'de>,
        ) -> ::core::option::Option<Self> {
            <
            Offer as ::fidl_next::FromWireOption<crate::wire_optional::Offer<'de>>
        >::from_wire_option(wire).map(Box::new)
        }
    }

    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::Offer<'de>> for Box<Offer> {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::Offer<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.as_ref() {
                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
            } else {
                None
            }
        }
    }

    #[doc = " A repository of the runners available in an environment.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct RunnerRegistration {
        pub source_name: ::core::option::Option<::std::string::String>,

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub target_name: ::core::option::Option<::std::string::String>,
    }

    impl RunnerRegistration {
        fn __max_ordinal(&self) -> usize {
            if self.target_name.is_some() {
                return 3;
            }

            if self.source.is_some() {
                return 2;
            }

            if self.source_name.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::RunnerRegistration<'static>, ___E>
        for RunnerRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::RunnerRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::RunnerRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RunnerRegistration<'static>, ___E>
        for &'a RunnerRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::RunnerRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::RunnerRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::RunnerRegistration<'de>> for RunnerRegistration {
        #[inline]
        fn from_wire(wire_: crate::wire::RunnerRegistration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source_name = wire_.table.get(1);

            let source = wire_.table.get(2);

            let target_name = wire_.table.get(3);

            Self {
                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::RunnerRegistration<'de>> for RunnerRegistration {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::RunnerRegistration<'de>) -> Self {
            Self {
                source_name: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                target_name: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[doc = " A mapping of URL scheme to resolver name.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ResolverRegistration {
        pub resolver: ::core::option::Option<::std::string::String>,

        pub source: ::core::option::Option<crate::natural::Ref>,

        pub scheme: ::core::option::Option<::std::string::String>,
    }

    impl ResolverRegistration {
        fn __max_ordinal(&self) -> usize {
            if self.scheme.is_some() {
                return 3;
            }

            if self.source.is_some() {
                return 2;
            }

            if self.resolver.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolverRegistration<'static>, ___E>
        for ResolverRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ResolverRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ResolverRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.scheme.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.resolver.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ResolverRegistration<'static>, ___E>
        for &'a ResolverRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ResolverRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ResolverRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.scheme {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.resolver {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ResolverRegistration<'de>> for ResolverRegistration {
        #[inline]
        fn from_wire(wire_: crate::wire::ResolverRegistration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let resolver = wire_.table.get(1);

            let source = wire_.table.get(2);

            let scheme = wire_.table.get(3);

            Self {
                resolver: resolver.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                scheme: scheme.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ResolverRegistration<'de>>
        for ResolverRegistration
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ResolverRegistration<'de>) -> Self {
            Self {
                resolver: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                source: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                scheme: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[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(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct DebugProtocolRegistration {
        pub source: ::core::option::Option<crate::natural::Ref>,

        pub source_name: ::core::option::Option<::std::string::String>,

        pub target_name: ::core::option::Option<::std::string::String>,
    }

    impl DebugProtocolRegistration {
        fn __max_ordinal(&self) -> usize {
            if self.target_name.is_some() {
                return 3;
            }

            if self.source_name.is_some() {
                return 2;
            }

            if self.source.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugProtocolRegistration<'static>, ___E>
        for DebugProtocolRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugProtocolRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugProtocolRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.target_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.source_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugProtocolRegistration<'static>, ___E>
        for &'a DebugProtocolRegistration
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugProtocolRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugProtocolRegistration { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.target_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.source_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Ref<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::DebugProtocolRegistration<'de>>
        for DebugProtocolRegistration
    {
        #[inline]
        fn from_wire(wire_: crate::wire::DebugProtocolRegistration<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let source = wire_.table.get(1);

            let source_name = wire_.table.get(2);

            let target_name = wire_.table.get(3);

            Self {
                source: source.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: source_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_name: target_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugProtocolRegistration<'de>>
        for DebugProtocolRegistration
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::DebugProtocolRegistration<'de>) -> Self {
            Self {
                source: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::Ref<'de>>()
                    })
                }),

                source_name: wire.table.get(2).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),

                target_name: wire.table.get(3).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[doc = " Declares a capability registered in the debug section of an environment.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum DebugRegistration {
        Protocol(crate::natural::DebugProtocolRegistration),

        UnknownOrdinal_(u64),
    }

    impl DebugRegistration {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugRegistration<'static>, ___E>
        for DebugRegistration
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugRegistration { raw, _phantom: _ } = out);

            match self {
                Self::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::DebugProtocolRegistration<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DebugRegistration<'static>, ___E>
        for &'a DebugRegistration
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::DebugRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::DebugRegistration { raw, _phantom: _ } = out);

            match self {
                DebugRegistration::Protocol(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::DebugProtocolRegistration<'static>,
                >(value, 1, encoder, raw, ())?,

                DebugRegistration::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<crate::wire_optional::DebugRegistration<'static>, ___E>
        for DebugRegistration
    where
        ___E: ?Sized,
        DebugRegistration: ::fidl_next::Encode<crate::wire::DebugRegistration<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DebugRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::DebugRegistration { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::DebugRegistration<'static>, ___E>
        for &'a DebugRegistration
    where
        ___E: ?Sized,
        &'a DebugRegistration: ::fidl_next::Encode<crate::wire::DebugRegistration<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DebugRegistration<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::DebugRegistration { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::DebugRegistration<'de>> for DebugRegistration {
        #[inline]
        fn from_wire(wire: crate::wire::DebugRegistration<'de>) -> Self {
            let wire = ::core::mem::ManuallyDrop::new(wire);
            match wire.raw.ordinal() {
                1 => Self::Protocol(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::DebugProtocolRegistration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::DebugRegistration<'de>> for DebugRegistration {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::DebugRegistration<'de>) -> Self {
            match wire.raw.ordinal() {
                1 => Self::Protocol(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::DebugProtocolRegistration<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DebugRegistration<'de>>
        for DebugRegistration
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::DebugRegistration<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DebugRegistration<'de>>
        for Box<DebugRegistration>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::DebugRegistration<'de>,
        ) -> ::core::option::Option<Self> {
            <DebugRegistration as ::fidl_next::FromWireOption<
                crate::wire_optional::DebugRegistration<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::DebugRegistration<'de>>
        for Box<DebugRegistration>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::DebugRegistration<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.as_ref() {
                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
            } else {
                None
            }
        }
    }

    #[doc = " Declares an environment which configures a realm.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Environment {
        pub name: ::core::option::Option<::std::string::String>,

        pub extends: ::core::option::Option<crate::natural::EnvironmentExtends>,

        pub runners: ::core::option::Option<::std::vec::Vec<crate::natural::RunnerRegistration>>,

        pub resolvers:
            ::core::option::Option<::std::vec::Vec<crate::natural::ResolverRegistration>>,

        pub debug_capabilities:
            ::core::option::Option<::std::vec::Vec<crate::natural::DebugRegistration>>,

        pub stop_timeout_ms: ::core::option::Option<u32>,
    }

    impl Environment {
        fn __max_ordinal(&self) -> usize {
            if self.stop_timeout_ms.is_some() {
                return 6;
            }

            if self.debug_capabilities.is_some() {
                return 5;
            }

            if self.resolvers.is_some() {
                return 4;
            }

            if self.runners.is_some() {
                return 3;
            }

            if self.extends.is_some() {
                return 2;
            }

            if self.name.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Environment<'static>, ___E> for Environment
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Environment<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Environment { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = self.stop_timeout_ms.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Uint32,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.debug_capabilities.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::DebugRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.resolvers.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ResolverRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.runners.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::RunnerRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.extends.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::EnvironmentExtends,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Environment<'static>, ___E>
        for &'a Environment
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Environment<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Environment { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    6 => {
                        if let Some(value) = &self.stop_timeout_ms {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Uint32,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.debug_capabilities {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::DebugRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.resolvers {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ResolverRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.runners {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::RunnerRegistration<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.extends {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::EnvironmentExtends,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Environment<'de>> for Environment {
        #[inline]
        fn from_wire(wire_: crate::wire::Environment<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let name = wire_.table.get(1);

            let extends = wire_.table.get(2);

            let runners = wire_.table.get(3);

            let resolvers = wire_.table.get(4);

            let debug_capabilities = wire_.table.get(5);

            let stop_timeout_ms = wire_.table.get(6);

            Self {


                name: name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::String<'de>>() }
                )),


                extends: extends.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::EnvironmentExtends>() }
                )),


                runners: runners.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::RunnerRegistration<'de>>>() }
                )),


                resolvers: resolvers.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ResolverRegistration<'de>>>() }
                )),


                debug_capabilities: debug_capabilities.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DebugRegistration<'de>>>() }
                )),


                stop_timeout_ms: stop_timeout_ms.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::Environment<'de>> for Environment {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::Environment<'de>) -> Self {
            Self {


                name: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::String<'de>>() }
                    )),


                extends: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::EnvironmentExtends>() }
                    )),


                runners: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::RunnerRegistration<'de>>>() }
                    )),


                resolvers: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ResolverRegistration<'de>>>() }
                    )),


                debug_capabilities: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DebugRegistration<'de>>>() }
                    )),


                stop_timeout_ms: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Uint32>() }
                    )),

        }
        }
    }

    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigSourceCapabilities {}

    impl ConfigSourceCapabilities {
        fn __max_ordinal(&self) -> usize {
            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigSourceCapabilities<'static>, ___E>
        for ConfigSourceCapabilities
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSourceCapabilities<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSourceCapabilities { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigSourceCapabilities<'static>, ___E>
        for &'a ConfigSourceCapabilities
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSourceCapabilities<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSourceCapabilities { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigSourceCapabilities<'de>>
        for ConfigSourceCapabilities
    {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigSourceCapabilities<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            Self {}
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigSourceCapabilities<'de>>
        for ConfigSourceCapabilities
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigSourceCapabilities<'de>) -> Self {
            Self {}
        }
    }

    #[doc = " Strategies available for resolving configuration values.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum ConfigValueSource {
        PackagePath(::std::string::String),

        Capabilities(crate::natural::ConfigSourceCapabilities),

        UnknownOrdinal_(u64),
    }

    impl ConfigValueSource {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigValueSource<'static>, ___E>
        for ConfigValueSource
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValueSource<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValueSource { raw, _phantom: _ } = out);

            match self {
                Self::PackagePath(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    ::fidl_next::wire::String<'static>,
                >(value, 1, encoder, raw, 4294967295)?,

                Self::Capabilities(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigSourceCapabilities<'static>,
                >(value, 2, encoder, raw, ())?,

                Self::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigValueSource<'static>, ___E>
        for &'a ConfigValueSource
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValueSource<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValueSource { raw, _phantom: _ } = out);

            match self {
                ConfigValueSource::PackagePath(value) => {
                    ::fidl_next::wire::Union::encode_as::<___E, ::fidl_next::wire::String<'static>>(
                        value, 1, encoder, raw, 4294967295,
                    )?
                }

                ConfigValueSource::Capabilities(value) => {
                    ::fidl_next::wire::Union::encode_as::<
                        ___E,
                        crate::wire::ConfigSourceCapabilities<'static>,
                    >(value, 2, encoder, raw, ())?
                }

                ConfigValueSource::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigValueSource<'static>, ___E>
        for ConfigValueSource
    where
        ___E: ?Sized,
        ConfigValueSource: ::fidl_next::Encode<crate::wire::ConfigValueSource<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigValueSource<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigValueSource { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::ConfigValueSource<'static>, ___E>
        for &'a ConfigValueSource
    where
        ___E: ?Sized,
        &'a ConfigValueSource: ::fidl_next::Encode<crate::wire::ConfigValueSource<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConfigValueSource<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::ConfigValueSource { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigValueSource<'de>> for ConfigValueSource {
        #[inline]
        fn from_wire(wire: crate::wire::ConfigValueSource<'de>) -> Self {
            let wire = ::core::mem::ManuallyDrop::new(wire);
            match wire.raw.ordinal() {
                1 => Self::PackagePath(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
                })),

                2 => Self::Capabilities(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::ConfigSourceCapabilities<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigValueSource<'de>> for ConfigValueSource {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigValueSource<'de>) -> Self {
            match wire.raw.ordinal() {
                1 => Self::PackagePath(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<::fidl_next::wire::String<'de>>()
                })),

                2 => Self::Capabilities(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::ConfigSourceCapabilities<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigValueSource<'de>>
        for ConfigValueSource
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigValueSource<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ConfigValueSource<'de>>
        for Box<ConfigValueSource>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::ConfigValueSource<'de>,
        ) -> ::core::option::Option<Self> {
            <ConfigValueSource as ::fidl_next::FromWireOption<
                crate::wire_optional::ConfigValueSource<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::ConfigValueSource<'de>>
        for Box<ConfigValueSource>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::ConfigValueSource<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.as_ref() {
                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
            } else {
                None
            }
        }
    }

    #[doc = " The schema of a component\'s configuration interface.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigSchema {
        pub fields: ::core::option::Option<::std::vec::Vec<crate::natural::ConfigField>>,

        pub checksum: ::core::option::Option<crate::natural::ConfigChecksum>,

        pub value_source: ::core::option::Option<crate::natural::ConfigValueSource>,
    }

    impl ConfigSchema {
        fn __max_ordinal(&self) -> usize {
            if self.value_source.is_some() {
                return 3;
            }

            if self.checksum.is_some() {
                return 2;
            }

            if self.fields.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigSchema<'static>, ___E> for ConfigSchema
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSchema<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSchema { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = self.value_source.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValueSource<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.checksum.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigChecksum<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.fields.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigField<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigSchema<'static>, ___E>
        for &'a ConfigSchema
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigSchema<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigSchema { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    3 => {
                        if let Some(value) = &self.value_source {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValueSource<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.checksum {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigChecksum<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.fields {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigField<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigSchema<'de>> for ConfigSchema {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigSchema<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let fields = wire_.table.get(1);

            let checksum = wire_.table.get(2);

            let value_source = wire_.table.get(3);

            Self {


                fields: fields.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigField<'de>>>() }
                )),


                checksum: checksum.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::ConfigChecksum<'de>>() }
                )),


                value_source: value_source.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::ConfigValueSource<'de>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigSchema<'de>> for ConfigSchema {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigSchema<'de>) -> Self {
            Self {


                fields: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigField<'de>>>() }
                    )),


                checksum: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::ConfigChecksum<'de>>() }
                    )),


                value_source: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::ConfigValueSource<'de>>() }
                    )),

        }
        }
    }

    #[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(Debug, Default, Clone, PartialEq)]
    pub struct Component {
        pub program: ::core::option::Option<crate::natural::Program>,

        pub uses: ::core::option::Option<::std::vec::Vec<crate::natural::Use>>,

        pub exposes: ::core::option::Option<::std::vec::Vec<crate::natural::Expose>>,

        pub offers: ::core::option::Option<::std::vec::Vec<crate::natural::Offer>>,

        pub capabilities: ::core::option::Option<::std::vec::Vec<crate::natural::Capability>>,

        pub children: ::core::option::Option<::std::vec::Vec<crate::natural::Child>>,

        pub collections: ::core::option::Option<::std::vec::Vec<crate::natural::Collection>>,

        pub environments: ::core::option::Option<::std::vec::Vec<crate::natural::Environment>>,

        pub facets: ::core::option::Option<::fidl_next_common_fuchsia_data::natural::Dictionary>,

        pub config: ::core::option::Option<crate::natural::ConfigSchema>,

        pub debug_info: ::core::option::Option<crate::natural::DebugInfo>,
    }

    impl Component {
        fn __max_ordinal(&self) -> usize {
            if self.debug_info.is_some() {
                return 11;
            }

            if self.config.is_some() {
                return 10;
            }

            if self.facets.is_some() {
                return 9;
            }

            if self.environments.is_some() {
                return 8;
            }

            if self.collections.is_some() {
                return 7;
            }

            if self.children.is_some() {
                return 6;
            }

            if self.capabilities.is_some() {
                return 5;
            }

            if self.offers.is_some() {
                return 4;
            }

            if self.exposes.is_some() {
                return 3;
            }

            if self.uses.is_some() {
                return 2;
            }

            if self.program.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Component<'static>, ___E> for Component
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Component<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Component { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    11 => {
                        if let Some(value) = self.debug_info.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DebugInfo<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    10 => {
                        if let Some(value) = self.config.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigSchema<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    9 => {
                        if let Some(value) = self.facets.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = self.environments.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Environment<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = self.collections.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Collection<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = self.children.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Child<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = self.capabilities.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Capability<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = self.offers.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Offer<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = self.exposes.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Expose<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = self.uses.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Use<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.program.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Program<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Component<'static>, ___E> for &'a Component
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::Component<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::Component { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    11 => {
                        if let Some(value) = &self.debug_info {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::DebugInfo<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    10 => {
                        if let Some(value) = &self.config {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigSchema<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    9 => {
                        if let Some(value) = &self.facets {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next_common_fuchsia_data::wire::Dictionary<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    8 => {
                        if let Some(value) = &self.environments {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Environment<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    7 => {
                        if let Some(value) = &self.collections {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Collection<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    6 => {
                        if let Some(value) = &self.children {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Child<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    5 => {
                        if let Some(value) = &self.capabilities {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::Capability<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    4 => {
                        if let Some(value) = &self.offers {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Offer<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    3 => {
                        if let Some(value) = &self.exposes {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Expose<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    2 => {
                        if let Some(value) = &self.uses {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<'static, crate::wire::Use<'static>>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.program {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::Program<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::Component<'de>> for Component {
        #[inline]
        fn from_wire(wire_: crate::wire::Component<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let program = wire_.table.get(1);

            let uses = wire_.table.get(2);

            let exposes = wire_.table.get(3);

            let offers = wire_.table.get(4);

            let capabilities = wire_.table.get(5);

            let children = wire_.table.get(6);

            let collections = wire_.table.get(7);

            let environments = wire_.table.get(8);

            let facets = wire_.table.get(9);

            let config = wire_.table.get(10);

            let debug_info = wire_.table.get(11);

            Self {


                program: program.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::Program<'de>>() }
                )),


                uses: uses.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Use<'de>>>() }
                )),


                exposes: exposes.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Expose<'de>>>() }
                )),


                offers: offers.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Offer<'de>>>() }
                )),


                capabilities: capabilities.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Capability<'de>>>() }
                )),


                children: children.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Child<'de>>>() }
                )),


                collections: collections.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Collection<'de>>>() }
                )),


                environments: environments.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Environment<'de>>>() }
                )),


                facets: facets.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>() }
                )),


                config: config.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::ConfigSchema<'de>>() }
                )),


                debug_info: debug_info.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::DebugInfo<'de>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::Component<'de>> for Component {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::Component<'de>) -> Self {
            Self {


                program: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::Program<'de>>() }
                    )),


                uses: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Use<'de>>>() }
                    )),


                exposes: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Expose<'de>>>() }
                    )),


                offers: wire.table.get(4)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Offer<'de>>>() }
                    )),


                capabilities: wire.table.get(5)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Capability<'de>>>() }
                    )),


                children: wire.table.get(6)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Child<'de>>>() }
                    )),


                collections: wire.table.get(7)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Collection<'de>>>() }
                    )),


                environments: wire.table.get(8)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Environment<'de>>>() }
                    )),


                facets: wire.table.get(9)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>() }
                    )),


                config: wire.table.get(10)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::ConfigSchema<'de>>() }
                    )),


                debug_info: wire.table.get(11)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::DebugInfo<'de>>() }
                    )),

        }
        }
    }

    #[doc = " An individual configuration value. It is matched against a specific configuration field based\n on its offset within `ValuesData.values`.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigValueSpec {
        pub value: ::core::option::Option<crate::natural::ConfigValue>,
    }

    impl ConfigValueSpec {
        fn __max_ordinal(&self) -> usize {
            if self.value.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigValueSpec<'static>, ___E>
        for ConfigValueSpec
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValueSpec<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValueSpec { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = self.value.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigValueSpec<'static>, ___E>
        for &'a ConfigValueSpec
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValueSpec<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValueSpec { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = &self.value {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigValue<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigValueSpec<'de>> for ConfigValueSpec {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigValueSpec<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let value = wire_.table.get(1);

            Self {
                value: value.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<crate::wire::ConfigValue<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigValueSpec<'de>> for ConfigValueSpec {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigValueSpec<'de>) -> Self {
            Self {
                value: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<crate::wire::ConfigValue<'de>>()
                    })
                }),
            }
        }
    }

    #[doc = " Contents of the configuration value file. Defines the base values for a component\'s config.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ConfigValuesData {
        pub values: ::core::option::Option<::std::vec::Vec<crate::natural::ConfigValueSpec>>,

        pub checksum: ::core::option::Option<crate::natural::ConfigChecksum>,
    }

    impl ConfigValuesData {
        fn __max_ordinal(&self) -> usize {
            if self.checksum.is_some() {
                return 2;
            }

            if self.values.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConfigValuesData<'static>, ___E>
        for ConfigValuesData
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValuesData<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValuesData { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = self.checksum.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigChecksum<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = self.values.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigValueSpec<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ConfigValuesData<'static>, ___E>
        for &'a ConfigValuesData
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ConfigValuesData<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ConfigValuesData { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    2 => {
                        if let Some(value) = &self.checksum {
                            ::fidl_next::wire::Envelope::encode_value::<
                                crate::wire::ConfigChecksum<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, ()
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    1 => {
                        if let Some(value) = &self.values {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::Vector<
                                    'static,
                                    crate::wire::ConfigValueSpec<'static>,
                                >,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, (4294967295, ())
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ConfigValuesData<'de>> for ConfigValuesData {
        #[inline]
        fn from_wire(wire_: crate::wire::ConfigValuesData<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let values = wire_.table.get(1);

            let checksum = wire_.table.get(2);

            Self {


                values: values.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigValueSpec<'de>>>() }
                )),


                checksum: checksum.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::wire::ConfigChecksum<'de>>() }
                )),

        }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ConfigValuesData<'de>> for ConfigValuesData {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ConfigValuesData<'de>) -> Self {
            Self {


                values: wire.table.get(1)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigValueSpec<'de>>>() }
                    )),


                checksum: wire.table.get(2)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<crate::wire::ConfigChecksum<'de>>() }
                    )),

        }
        }
    }

    #[doc = " Indicates the event name to subscribe to with a given event mode.\n"]
    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct EventSubscription {
        pub event_name: ::core::option::Option<::std::string::String>,
    }

    impl EventSubscription {
        fn __max_ordinal(&self) -> usize {
            if self.event_name.is_some() {
                return 1;
            }

            0
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventSubscription<'static>, ___E>
        for EventSubscription
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            mut self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::EventSubscription<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::EventSubscription { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = self.event_name.take() {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventSubscription<'static>, ___E>
        for &'a EventSubscription
    where
        ___E: ::fidl_next::Encoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::EventSubscription<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::EventSubscription { table } = out);

            let max_ord = self.__max_ordinal();

            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
            ::fidl_next::Wire::zero_padding(&mut out);

            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
                ::fidl_next::wire::Envelope,
            >(encoder, max_ord);

            for i in 1..=max_ord {
                match i {
                    1 => {
                        if let Some(value) = &self.event_name {
                            ::fidl_next::wire::Envelope::encode_value::<
                                ::fidl_next::wire::String<'static>,
                                ___E,
                            >(
                                value, preallocated.encoder, &mut out, 100
                            )?;
                        } else {
                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
                        }
                    }

                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
                }
                unsafe {
                    preallocated.write_next(out.assume_init_ref());
                }
            }

            ::fidl_next::wire::Table::encode_len(table, max_ord);

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::EventSubscription<'de>> for EventSubscription {
        #[inline]
        fn from_wire(wire_: crate::wire::EventSubscription<'de>) -> Self {
            let wire_ = ::core::mem::ManuallyDrop::new(wire_);

            let event_name = wire_.table.get(1);

            Self {
                event_name: event_name.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::EventSubscription<'de>> for EventSubscription {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::EventSubscription<'de>) -> Self {
            Self {
                event_name: wire.table.get(1).map(|envelope| {
                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                        envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
                    })
                }),
            }
        }
    }

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub enum LayoutParameter {
        NestedType(crate::natural::ConfigType),

        UnknownOrdinal_(u64),
    }

    impl LayoutParameter {
        pub fn is_unknown(&self) -> bool {
            #[allow(unreachable_patterns)]
            match self {
                Self::UnknownOrdinal_(_) => true,
                _ => false,
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::LayoutParameter<'static>, ___E>
        for LayoutParameter
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::LayoutParameter<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::LayoutParameter { raw, _phantom: _ } = out);

            match self {
                Self::NestedType(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigType<'static>,
                >(value, 1, encoder, raw, ())?,

                Self::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::LayoutParameter<'static>, ___E>
        for &'a LayoutParameter
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::LayoutParameter<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::LayoutParameter { raw, _phantom: _ } = out);

            match self {
                LayoutParameter::NestedType(value) => ::fidl_next::wire::Union::encode_as::<
                    ___E,
                    crate::wire::ConfigType<'static>,
                >(value, 1, encoder, raw, ())?,

                LayoutParameter::UnknownOrdinal_(ordinal) => {
                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
                }
            }

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<crate::wire_optional::LayoutParameter<'static>, ___E>
        for LayoutParameter
    where
        ___E: ?Sized,
        LayoutParameter: ::fidl_next::Encode<crate::wire::LayoutParameter<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::LayoutParameter<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::LayoutParameter { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<crate::wire_optional::LayoutParameter<'static>, ___E>
        for &'a LayoutParameter
    where
        ___E: ?Sized,
        &'a LayoutParameter: ::fidl_next::Encode<crate::wire::LayoutParameter<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::LayoutParameter<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire_optional::LayoutParameter { raw, _phantom: _ } = &mut *out);

            if let Some(inner) = this {
                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
            } else {
                ::fidl_next::wire::Union::encode_absent(raw);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::LayoutParameter<'de>> for LayoutParameter {
        #[inline]
        fn from_wire(wire: crate::wire::LayoutParameter<'de>) -> Self {
            let wire = ::core::mem::ManuallyDrop::new(wire);
            match wire.raw.ordinal() {
                1 => Self::NestedType(::fidl_next::FromWire::from_wire(unsafe {
                    wire.raw.get().read_unchecked::<crate::wire::ConfigType<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::LayoutParameter<'de>> for LayoutParameter {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::LayoutParameter<'de>) -> Self {
            match wire.raw.ordinal() {
                1 => Self::NestedType(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    wire.raw.get().deref_unchecked::<crate::wire::ConfigType<'de>>()
                })),

                ord => return Self::UnknownOrdinal_(ord as u64),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::LayoutParameter<'de>>
        for LayoutParameter
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::LayoutParameter<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.into_option() {
                Some(::fidl_next::FromWire::from_wire(inner))
            } else {
                None
            }
        }
    }

    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::LayoutParameter<'de>>
        for Box<LayoutParameter>
    {
        #[inline]
        fn from_wire_option(
            wire: crate::wire_optional::LayoutParameter<'de>,
        ) -> ::core::option::Option<Self> {
            <LayoutParameter as ::fidl_next::FromWireOption<
                crate::wire_optional::LayoutParameter<'de>,
            >>::from_wire_option(wire)
            .map(Box::new)
        }
    }

    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::LayoutParameter<'de>>
        for Box<LayoutParameter>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::LayoutParameter<'de>,
        ) -> ::core::option::Option<Self> {
            if let Some(inner) = wire.as_ref() {
                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
            } else {
                None
            }
        }
    }

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ResolvedConfigField {
        pub key: ::std::string::String,

        pub value: crate::natural::ConfigValue,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolvedConfigField<'static>, ___E>
        for ResolvedConfigField
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfigField<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfigField {
                    key,
                    value,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.key, encoder_, key, 4294967295)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 4294967295)?;

            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ResolvedConfigField<'static>, ___E>
        for &'a ResolvedConfigField
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfigField<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfigField {
                    key,
                    value,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.key, encoder_, key, 4294967295)?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, 4294967295)?;

            ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfigField<'static>>,
            ___E,
        > for ResolvedConfigField
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        ResolvedConfigField: ::fidl_next::Encode<crate::wire::ResolvedConfigField<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfigField<'static>>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfigField<'static>>,
            ___E,
        > for &'a ResolvedConfigField
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a ResolvedConfigField:
            ::fidl_next::Encode<crate::wire::ResolvedConfigField<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfigField<'static>>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ResolvedConfigField<'de>> for ResolvedConfigField {
        #[inline]
        fn from_wire(wire: crate::wire::ResolvedConfigField<'de>) -> Self {
            Self {
                key: ::fidl_next::FromWire::from_wire(wire.key),

                value: ::fidl_next::FromWire::from_wire(wire.value),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ResolvedConfigField<'de>> for ResolvedConfigField {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ResolvedConfigField<'de>) -> Self {
            Self {
                key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),

                value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
            }
        }
    }

    #[doc = " A configuration that has been completely resolved by component manager.\n"]
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ResolvedConfig {
        pub fields: ::std::vec::Vec<crate::natural::ResolvedConfigField>,

        pub checksum: crate::natural::ConfigChecksum,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolvedConfig<'static>, ___E> for ResolvedConfig
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfig<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfig {
                    fields,
                    checksum,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.fields, encoder_, fields, (4294967295, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fields.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            ::fidl_next::Encode::encode(self.checksum, encoder_, checksum, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(checksum.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ResolvedConfig<'static>, ___E>
        for &'a ResolvedConfig
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfig<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfig {
                    fields,
                    checksum,

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.fields, encoder_, fields, (4294967295, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fields.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;

            ::fidl_next::Encode::encode(&self.checksum, encoder_, checksum, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(checksum.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfig<'static>>,
            ___E,
        > for ResolvedConfig
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        ResolvedConfig: ::fidl_next::Encode<crate::wire::ResolvedConfig<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfig<'static>>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfig<'static>>,
            ___E,
        > for &'a ResolvedConfig
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a ResolvedConfig: ::fidl_next::Encode<crate::wire::ResolvedConfig<'static>, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::ResolvedConfig<'static>>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::ResolvedConfig<'de>> for ResolvedConfig {
        #[inline]
        fn from_wire(wire: crate::wire::ResolvedConfig<'de>) -> Self {
            Self {
                fields: ::fidl_next::FromWire::from_wire(wire.fields),

                checksum: ::fidl_next::FromWire::from_wire(wire.checksum),
            }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ResolvedConfig<'de>> for ResolvedConfig {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ResolvedConfig<'de>) -> Self {
            Self {
                fields: ::fidl_next::FromWireRef::from_wire_ref(&wire.fields),

                checksum: ::fidl_next::FromWireRef::from_wire_ref(&wire.checksum),
            }
        }
    }
}

pub mod wire {

    /// The wire type corresponding to [`AllowedOffers`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct AllowedOffers {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for AllowedOffers {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for AllowedOffers {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl AllowedOffers {
        pub const STATIC_ONLY: AllowedOffers =
            AllowedOffers { value: ::fidl_next::wire::Uint32(1) };

        pub const STATIC_AND_DYNAMIC: AllowedOffers =
            AllowedOffers { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for AllowedOffers
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::AllowedOffers> for AllowedOffers {
        fn from(natural: crate::natural::AllowedOffers) -> Self {
            match natural {
                crate::natural::AllowedOffers::StaticOnly => AllowedOffers::STATIC_ONLY,

                crate::natural::AllowedOffers::StaticAndDynamic => {
                    AllowedOffers::STATIC_AND_DYNAMIC
                }
            }
        }
    }

    impl ::fidl_next::IntoNatural for AllowedOffers {
        type Natural = crate::natural::AllowedOffers;
    }

    /// The wire type corresponding to [`Availability`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Availability {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for Availability {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Availability {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl Availability {
        pub const REQUIRED: Availability = Availability { value: ::fidl_next::wire::Uint32(1) };

        pub const OPTIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(2) };

        pub const SAME_AS_TARGET: Availability =
            Availability { value: ::fidl_next::wire::Uint32(3) };

        pub const TRANSITIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(4) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for Availability
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::Availability> for Availability {
        fn from(natural: crate::natural::Availability) -> Self {
            match natural {
                crate::natural::Availability::Required => Availability::REQUIRED,

                crate::natural::Availability::Optional => Availability::OPTIONAL,

                crate::natural::Availability::SameAsTarget => Availability::SAME_AS_TARGET,

                crate::natural::Availability::Transitional => Availability::TRANSITIONAL,
            }
        }
    }

    impl ::fidl_next::IntoNatural for Availability {
        type Natural = crate::natural::Availability;
    }

    /// The wire type corresponding to [`Name`](crate::natural::Name).
    pub type Name<'de> = ::fidl_next::wire::String<'de>;

    /// The wire type corresponding to [`Service`].
    #[repr(C)]
    pub struct Service<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Service<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Service<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Service<'static> {
        type Narrowed<'de> = Service<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Service<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Service<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Service<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Service")
                .field("name", &self.name())
                .field("source_path", &self.source_path())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Service<'de> {
        type Natural = crate::natural::Service;
    }

    /// The wire type corresponding to [`Directory`].
    #[repr(C)]
    pub struct Directory<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Directory<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
            });
        }
    }

    impl ::fidl_next::Constrained for Directory<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Directory<'static> {
        type Narrowed<'de> = Directory<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Directory<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_io::wire::Operations,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Directory<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn rights(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_io::wire::Operations> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Directory<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Directory")
                .field("name", &self.name())
                .field("source_path", &self.source_path())
                .field("rights", &self.rights())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Directory<'de> {
        type Natural = crate::natural::Directory;
    }

    /// The wire type corresponding to [`ParentRef`].
    pub type ParentRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`SelfRef`].
    pub type SelfRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`ChildName`](crate::natural::ChildName).
    pub type ChildName<'de> = ::fidl_next::wire::String<'de>;

    /// The wire type corresponding to [`ChildRef`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ChildRef<'de> {
        pub name: ::fidl_next::wire::String<'de>,

        pub collection: ::fidl_next::wire::OptionalString<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<ChildRef<'_>>(), 32);
    static_assertions::const_assert_eq!(std::mem::align_of::<ChildRef<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ChildRef<'_>, name), 0);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ChildRef<'_>, collection), 16);

    impl ::fidl_next::Constrained for ChildRef<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ChildRef<'static> {
        type Narrowed<'de> = ChildRef<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    name,
                    collection,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);

            ::fidl_next::Wire::zero_padding(collection);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ChildRef<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,
                    mut collection,

                } = slot_;
            }

            let _field = name.as_mut();
            ::fidl_next::Constrained::validate(_field, 1024)?;
            ::fidl_next::Decode::decode(name.as_mut(), decoder_, 1024)?;

            let name = unsafe { name.deref_unchecked() };

            if name.len() > 1024 {
                return Err(::fidl_next::DecodeError::VectorTooLong {
                    size: name.len() as u64,
                    limit: 1024,
                });
            }

            let _field = collection.as_mut();
            ::fidl_next::Constrained::validate(_field, 100)?;
            ::fidl_next::Decode::decode(collection.as_mut(), decoder_, 100)?;

            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(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ChildRef<'de> {
        type Natural = crate::natural::ChildRef;
    }

    /// The wire type corresponding to [`CollectionRef`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct CollectionRef<'de> {
        pub name: ::fidl_next::wire::String<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<CollectionRef<'_>>(), 16);
    static_assertions::const_assert_eq!(std::mem::align_of::<CollectionRef<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(CollectionRef<'_>, name), 0);

    impl ::fidl_next::Constrained for CollectionRef<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for CollectionRef<'static> {
        type Narrowed<'de> = CollectionRef<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    name,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CollectionRef<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,

                } = slot_;
            }

            let _field = name.as_mut();
            ::fidl_next::Constrained::validate(_field, 100)?;
            ::fidl_next::Decode::decode(name.as_mut(), decoder_, 100)?;

            let name = unsafe { name.deref_unchecked() };

            if name.len() > 100 {
                return Err(::fidl_next::DecodeError::VectorTooLong {
                    size: name.len() as u64,
                    limit: 100,
                });
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for CollectionRef<'de> {
        type Natural = crate::natural::CollectionRef;
    }

    /// The wire type corresponding to [`FrameworkRef`].
    pub type FrameworkRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`CapabilityRef`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct CapabilityRef<'de> {
        pub name: ::fidl_next::wire::String<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityRef<'_>>(), 16);
    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityRef<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityRef<'_>, name), 0);

    impl ::fidl_next::Constrained for CapabilityRef<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for CapabilityRef<'static> {
        type Narrowed<'de> = CapabilityRef<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    name,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityRef<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,

                } = slot_;
            }

            let _field = name.as_mut();
            ::fidl_next::Constrained::validate(_field, 100)?;
            ::fidl_next::Decode::decode(name.as_mut(), decoder_, 100)?;

            let name = unsafe { name.deref_unchecked() };

            if name.len() > 100 {
                return Err(::fidl_next::DecodeError::VectorTooLong {
                    size: name.len() as u64,
                    limit: 100,
                });
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for CapabilityRef<'de> {
        type Natural = crate::natural::CapabilityRef;
    }

    /// The wire type corresponding to [`DebugRef`].
    pub type DebugRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`VoidRef`].
    pub type VoidRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`StorageId`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct StorageId {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for StorageId {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for StorageId {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl StorageId {
        pub const STATIC_INSTANCE_ID: StorageId = StorageId { value: ::fidl_next::wire::Uint32(1) };

        pub const STATIC_INSTANCE_ID_OR_MONIKER: StorageId =
            StorageId { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for StorageId
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::StorageId> for StorageId {
        fn from(natural: crate::natural::StorageId) -> Self {
            match natural {
                crate::natural::StorageId::StaticInstanceId => StorageId::STATIC_INSTANCE_ID,

                crate::natural::StorageId::StaticInstanceIdOrMoniker => {
                    StorageId::STATIC_INSTANCE_ID_OR_MONIKER
                }
            }
        }
    }

    impl ::fidl_next::IntoNatural for StorageId {
        type Natural = crate::natural::StorageId;
    }

    /// The wire type corresponding to [`Runner`].
    #[repr(C)]
    pub struct Runner<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Runner<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Runner<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Runner<'static> {
        type Narrowed<'de> = Runner<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Runner<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Runner<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Runner<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Runner")
                .field("name", &self.name())
                .field("source_path", &self.source_path())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Runner<'de> {
        type Natural = crate::natural::Runner;
    }

    /// The wire type corresponding to [`Resolver`].
    #[repr(C)]
    pub struct Resolver<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Resolver<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Resolver<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Resolver<'static> {
        type Narrowed<'de> = Resolver<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Resolver<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Resolver<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Resolver<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Resolver")
                .field("name", &self.name())
                .field("source_path", &self.source_path())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Resolver<'de> {
        type Natural = crate::natural::Resolver;
    }

    /// The wire type corresponding to [`EventStream`].
    #[repr(C)]
    pub struct EventStream<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for EventStream<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for EventStream<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for EventStream<'static> {
        type Narrowed<'de> = EventStream<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStream<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> EventStream<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for EventStream<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("EventStream").field("name", &self.name()).finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for EventStream<'de> {
        type Natural = crate::natural::EventStream;
    }

    /// The wire type corresponding to [`ConfigSingleValue`].
    #[repr(transparent)]
    pub struct ConfigSingleValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for ConfigSingleValue<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<bool>() };
                }

                2 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<u8>() };
                }

                3 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint16>() };
                }

                4 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
                }

                5 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint64>() };
                }

                6 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<i8>() };
                }

                7 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Int16>() };
                }

                8 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Int32>() };
                }

                9 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Int64>() };
                }

                10 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for ConfigSingleValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigSingleValue<'static> {
        type Narrowed<'de> = ConfigSingleValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod config_single_value {
        pub enum Ref<'de> {
            Bool(&'de bool),

            Uint8(&'de u8),

            Uint16(&'de ::fidl_next::wire::Uint16),

            Uint32(&'de ::fidl_next::wire::Uint32),

            Uint64(&'de ::fidl_next::wire::Uint64),

            Int8(&'de i8),

            Int16(&'de ::fidl_next::wire::Int16),

            Int32(&'de ::fidl_next::wire::Int32),

            Int64(&'de ::fidl_next::wire::Int64),

            String(&'de ::fidl_next::wire::String<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> ConfigSingleValue<'de> {
        pub fn as_ref(&self) -> crate::wire::config_single_value::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::config_single_value::Ref::Bool(unsafe {
                    self.raw.get().deref_unchecked::<bool>()
                }),

                2 => crate::wire::config_single_value::Ref::Uint8(unsafe {
                    self.raw.get().deref_unchecked::<u8>()
                }),

                3 => crate::wire::config_single_value::Ref::Uint16(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint16>()
                }),

                4 => crate::wire::config_single_value::Ref::Uint32(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
                }),

                5 => crate::wire::config_single_value::Ref::Uint64(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
                }),

                6 => crate::wire::config_single_value::Ref::Int8(unsafe {
                    self.raw.get().deref_unchecked::<i8>()
                }),

                7 => crate::wire::config_single_value::Ref::Int16(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Int16>()
                }),

                8 => crate::wire::config_single_value::Ref::Int32(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Int32>()
                }),

                9 => crate::wire::config_single_value::Ref::Int64(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>()
                }),

                10 => crate::wire::config_single_value::Ref::String(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
                }),

                unknown => crate::wire::config_single_value::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigSingleValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, bool>(raw, decoder, ())?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, u8>(raw, decoder, ())?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint16>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, i8>(raw, decoder, ())?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int16>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int32>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
                    raw,
                    decoder,
                    (),
                )?,

                10 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
                    raw, decoder, 4294967295,
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigSingleValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
                2 => unsafe { self.raw.get().deref_unchecked::<u8>().fmt(f) },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint16>().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
                },
                5 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>().fmt(f)
                },
                6 => unsafe { self.raw.get().deref_unchecked::<i8>().fmt(f) },
                7 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::wire::Int16>().fmt(f) },
                8 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::wire::Int32>().fmt(f) },
                9 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>().fmt(f) },
                10 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigSingleValue<'de> {
        type Natural = crate::natural::ConfigSingleValue;
    }

    /// The wire type corresponding to [`ConfigVectorValue`].
    #[repr(transparent)]
    pub struct ConfigVectorValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for ConfigVectorValue<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, bool>>()
                    };
                }

                2 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
                    };
                }

                3 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>>()
                    };
                }

                4 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint32>>()
                    };
                }

                5 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint64>>()
                    };
                }

                6 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, i8>>()
                    };
                }

                7 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int16>>()
                    };
                }

                8 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int32>>()
                    };
                }

                9 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int64>>()
                    };
                }

                10 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for ConfigVectorValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigVectorValue<'static> {
        type Narrowed<'de> = ConfigVectorValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod config_vector_value {
        pub enum Ref<'de> {
            BoolVector(&'de ::fidl_next::wire::Vector<'de, bool>),

            Uint8Vector(&'de ::fidl_next::wire::Vector<'de, u8>),

            Uint16Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>),

            Uint32Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint32>),

            Uint64Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint64>),

            Int8Vector(&'de ::fidl_next::wire::Vector<'de, i8>),

            Int16Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int16>),

            Int32Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int32>),

            Int64Vector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int64>),

            StringVector(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> ConfigVectorValue<'de> {
        pub fn as_ref(&self) -> crate::wire::config_vector_value::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::config_vector_value::Ref::BoolVector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, bool>>()
                }),

                2 => crate::wire::config_vector_value::Ref::Uint8Vector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
                }),

                3 => crate::wire::config_vector_value::Ref::Uint16Vector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint16>>()
                }),

                4 => crate::wire::config_vector_value::Ref::Uint32Vector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint32>>()
                }),

                5 => crate::wire::config_vector_value::Ref::Uint64Vector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint64>>()
                }),

                6 => crate::wire::config_vector_value::Ref::Int8Vector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, i8>>()
                }),

                7 => {
                    crate::wire::config_vector_value::Ref::Int16Vector(unsafe {
                        self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int16>>()
                    })
                }

                8 => {
                    crate::wire::config_vector_value::Ref::Int32Vector(unsafe {
                        self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int32>>()
                    })
                }

                9 => {
                    crate::wire::config_vector_value::Ref::Int64Vector(unsafe {
                        self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int64>>()
                    })
                }

                10 => crate::wire::config_vector_value::Ref::StringVector(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>>()
                }),

                unknown => crate::wire::config_vector_value::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigVectorValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, bool>,
                >(raw, decoder, (4294967295, ()))?,

                2 => {
                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
                        raw,
                        decoder,
                        (4294967295, ()),
                    )?
                }

                3 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
                >(raw, decoder, (4294967295, ()))?,

                4 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint32>,
                >(raw, decoder, (4294967295, ()))?,

                5 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint64>,
                >(raw, decoder, (4294967295, ()))?,

                6 => {
                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, i8>>(
                        raw,
                        decoder,
                        (4294967295, ()),
                    )?
                }

                7 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int16>,
                >(raw, decoder, (4294967295, ()))?,

                8 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int32>,
                >(raw, decoder, (4294967295, ()))?,

                9 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int64>,
                >(raw, decoder, (4294967295, ()))?,

                10 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
                >(raw, decoder, (4294967295, 4294967295))?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigVectorValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, bool>>().fmt(f)
                },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
                },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<
                            ::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint16>
                        >().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<
                            ::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint32>
                        >().fmt(f)
                },
                5 => unsafe {
                    self.raw.get().deref_unchecked::<
                            ::fidl_next::wire::Vector<'_, ::fidl_next::wire::Uint64>
                        >().fmt(f)
                },
                6 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, i8>>().fmt(f)
                },
                7 => unsafe {
                    self.raw
                        .get()
                        .deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int16>>(
                        )
                        .fmt(f)
                },
                8 => unsafe {
                    self.raw
                        .get()
                        .deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int32>>(
                        )
                        .fmt(f)
                },
                9 => unsafe {
                    self.raw
                        .get()
                        .deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::Int64>>(
                        )
                        .fmt(f)
                },
                10 => unsafe {
                    self.raw.get().deref_unchecked::<
                            ::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>
                        >().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigVectorValue<'de> {
        type Natural = crate::natural::ConfigVectorValue;
    }

    /// The wire type corresponding to [`ConfigValue`].
    #[repr(transparent)]
    pub struct ConfigValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for ConfigValue<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ConfigSingleValue<'de>>()
                    };
                }

                2 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ConfigVectorValue<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for ConfigValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValue<'static> {
        type Narrowed<'de> = ConfigValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod config_value {
        pub enum Ref<'de> {
            Single(&'de crate::wire::ConfigSingleValue<'de>),

            Vector(&'de crate::wire::ConfigVectorValue<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> ConfigValue<'de> {
        pub fn as_ref(&self) -> crate::wire::config_value::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::config_value::Ref::Single(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigSingleValue<'_>>()
                }),

                2 => crate::wire::config_value::Ref::Vector(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigVectorValue<'_>>()
                }),

                unknown => crate::wire::config_value::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigSingleValue<'de>,
                >(raw, decoder, ())?,

                2 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigVectorValue<'de>,
                >(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigSingleValue<'_>>().fmt(f)
                },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigVectorValue<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValue<'de> {
        type Natural = crate::natural::ConfigValue;
    }

    /// The wire type corresponding to [`Configuration`].
    #[repr(C)]
    pub struct Configuration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Configuration<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigValue<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Configuration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Configuration<'static> {
        type Narrowed<'de> = Configuration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Configuration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigValue<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Configuration<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn value(&self) -> ::core::option::Option<&crate::wire::ConfigValue<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Configuration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Configuration")
                .field("name", &self.name())
                .field("value", &self.value())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Configuration<'de> {
        type Natural = crate::natural::Configuration;
    }

    /// The wire type corresponding to [`DictionaryPath`](crate::natural::DictionaryPath).
    pub type DictionaryPath<'de> = ::fidl_next::wire::String<'de>;

    /// The wire type corresponding to [`DeliveryType`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct DeliveryType {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for DeliveryType {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DeliveryType {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl DeliveryType {
        pub const IMMEDIATE: DeliveryType = DeliveryType { value: ::fidl_next::wire::Uint32(0) };

        pub const ON_READABLE: DeliveryType = DeliveryType { value: ::fidl_next::wire::Uint32(1) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for DeliveryType
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::DeliveryType> for DeliveryType {
        fn from(natural: crate::natural::DeliveryType) -> Self {
            match natural {
                crate::natural::DeliveryType::Immediate => DeliveryType::IMMEDIATE,

                crate::natural::DeliveryType::OnReadable => DeliveryType::ON_READABLE,

                crate::natural::DeliveryType::UnknownOrdinal_(value) => {
                    DeliveryType { value: ::fidl_next::wire::Uint32::from(value) }
                }
            }
        }
    }

    impl ::fidl_next::IntoNatural for DeliveryType {
        type Natural = crate::natural::DeliveryType;
    }

    /// The wire type corresponding to [`Protocol`].
    #[repr(C)]
    pub struct Protocol<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Protocol<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DeliveryType>() });
        }
    }

    impl ::fidl_next::Constrained for Protocol<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Protocol<'static> {
        type Narrowed<'de> = Protocol<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Protocol<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DeliveryType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Protocol<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn delivery(&self) -> ::core::option::Option<&crate::wire::DeliveryType> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Protocol<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Protocol")
                .field("name", &self.name())
                .field("source_path", &self.source_path())
                .field("delivery", &self.delivery())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Protocol<'de> {
        type Natural = crate::natural::Protocol;
    }

    /// The wire type corresponding to [`EnvironmentRef`].
    pub type EnvironmentRef = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`Ref`].
    #[repr(transparent)]
    pub struct Ref<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for Ref<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::ParentRef>() };
                }

                2 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::SelfRef>() };
                }

                3 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::ChildRef<'de>>() };
                }

                4 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::CollectionRef<'de>>()
                    };
                }

                5 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FrameworkRef>() };
                }

                6 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::CapabilityRef<'de>>()
                    };
                }

                7 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DebugRef>() };
                }

                8 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::VoidRef>() };
                }

                9 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::EnvironmentRef>() };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for Ref<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Ref<'static> {
        type Narrowed<'de> = Ref<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod ref_ {
        pub enum Ref<'de> {
            Parent(&'de crate::wire::ParentRef),

            Self_(&'de crate::wire::SelfRef),

            Child(&'de crate::wire::ChildRef<'de>),

            Collection(&'de crate::wire::CollectionRef<'de>),

            Framework(&'de crate::wire::FrameworkRef),

            Capability(&'de crate::wire::CapabilityRef<'de>),

            Debug(&'de crate::wire::DebugRef),

            VoidType(&'de crate::wire::VoidRef),

            Environment(&'de crate::wire::EnvironmentRef),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> Ref<'de> {
        pub fn as_ref(&self) -> crate::wire::ref_::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::ref_::Ref::Parent(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ParentRef>()
                }),

                2 => crate::wire::ref_::Ref::Self_(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::SelfRef>()
                }),

                3 => crate::wire::ref_::Ref::Child(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ChildRef<'_>>()
                }),

                4 => crate::wire::ref_::Ref::Collection(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::CollectionRef<'_>>()
                }),

                5 => crate::wire::ref_::Ref::Framework(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::FrameworkRef>()
                }),

                6 => crate::wire::ref_::Ref::Capability(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::CapabilityRef<'_>>()
                }),

                7 => crate::wire::ref_::Ref::Debug(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::DebugRef>()
                }),

                8 => crate::wire::ref_::Ref::VoidType(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::VoidRef>()
                }),

                9 => crate::wire::ref_::Ref::Environment(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::EnvironmentRef>()
                }),

                unknown => crate::wire::ref_::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Ref<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ParentRef>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SelfRef>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ChildRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::CollectionRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FrameworkRef>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::CapabilityRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DebugRef>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::VoidRef>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EnvironmentRef>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Ref<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::ParentRef>().fmt(f) },
                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::SelfRef>().fmt(f) },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ChildRef<'_>>().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::CollectionRef<'_>>().fmt(f)
                },
                5 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::FrameworkRef>().fmt(f)
                },
                6 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::CapabilityRef<'_>>().fmt(f)
                },
                7 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DebugRef>().fmt(f) },
                8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::VoidRef>().fmt(f) },
                9 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::EnvironmentRef>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Ref<'de> {
        type Natural = crate::natural::Ref;
    }

    /// The wire type corresponding to [`Storage`].
    #[repr(C)]
    pub struct Storage<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Storage<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::StorageId>() });
        }
    }

    impl ::fidl_next::Constrained for Storage<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Storage<'static> {
        type Narrowed<'de> = Storage<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Storage<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::StorageId>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Storage<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn backing_dir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn storage_id(&self) -> ::core::option::Option<&crate::wire::StorageId> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Storage<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Storage<'de> {
        type Natural = crate::natural::Storage;
    }

    /// The wire type corresponding to [`Dictionary`].
    #[repr(C)]
    pub struct Dictionary<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Dictionary<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Dictionary<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Dictionary<'static> {
        type Narrowed<'de> = Dictionary<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Dictionary<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Dictionary<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn source_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Dictionary<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Dictionary<'de> {
        type Natural = crate::natural::Dictionary;
    }

    /// The wire type corresponding to [`Capability`].
    #[repr(transparent)]
    pub struct Capability<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for Capability<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service<'de>>() };
                }

                2 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::Protocol<'de>>() };
                }

                3 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::Directory<'de>>() };
                }

                4 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Storage<'de>>() };
                }

                5 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Runner<'de>>() };
                }

                6 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::Resolver<'de>>() };
                }

                8 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::EventStream<'de>>() };
                }

                9 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::Dictionary<'de>>() };
                }

                10 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::Configuration<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for Capability<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Capability<'static> {
        type Narrowed<'de> = Capability<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod capability {
        pub enum Ref<'de> {
            Service(&'de crate::wire::Service<'de>),

            Protocol(&'de crate::wire::Protocol<'de>),

            Directory(&'de crate::wire::Directory<'de>),

            Storage(&'de crate::wire::Storage<'de>),

            Runner(&'de crate::wire::Runner<'de>),

            Resolver(&'de crate::wire::Resolver<'de>),

            EventStream(&'de crate::wire::EventStream<'de>),

            Dictionary(&'de crate::wire::Dictionary<'de>),

            Config(&'de crate::wire::Configuration<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> Capability<'de> {
        pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::capability::Ref::Service(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Service<'_>>()
                }),

                2 => crate::wire::capability::Ref::Protocol(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Protocol<'_>>()
                }),

                3 => crate::wire::capability::Ref::Directory(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Directory<'_>>()
                }),

                4 => crate::wire::capability::Ref::Storage(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Storage<'_>>()
                }),

                5 => crate::wire::capability::Ref::Runner(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Runner<'_>>()
                }),

                6 => crate::wire::capability::Ref::Resolver(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Resolver<'_>>()
                }),

                8 => crate::wire::capability::Ref::EventStream(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::EventStream<'_>>()
                }),

                9 => crate::wire::capability::Ref::Dictionary(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Dictionary<'_>>()
                }),

                10 => crate::wire::capability::Ref::Config(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Configuration<'_>>()
                }),

                unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Protocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Directory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Storage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Runner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Resolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EventStream<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Dictionary<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                10 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Configuration<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Capability<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service<'_>>().fmt(f) },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Protocol<'_>>().fmt(f)
                },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Directory<'_>>().fmt(f)
                },
                4 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Storage<'_>>().fmt(f) },
                5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Runner<'_>>().fmt(f) },
                6 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Resolver<'_>>().fmt(f)
                },
                8 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::EventStream<'_>>().fmt(f)
                },
                9 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Dictionary<'_>>().fmt(f)
                },
                10 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::Configuration<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
        type Natural = crate::natural::Capability;
    }

    /// The wire type corresponding to [`StartupMode`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct StartupMode {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for StartupMode {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for StartupMode {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl StartupMode {
        pub const LAZY: StartupMode = StartupMode { value: ::fidl_next::wire::Uint32(0) };

        pub const EAGER: StartupMode = StartupMode { value: ::fidl_next::wire::Uint32(1) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for StartupMode
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::StartupMode> for StartupMode {
        fn from(natural: crate::natural::StartupMode) -> Self {
            match natural {
                crate::natural::StartupMode::Lazy => StartupMode::LAZY,

                crate::natural::StartupMode::Eager => StartupMode::EAGER,
            }
        }
    }

    impl ::fidl_next::IntoNatural for StartupMode {
        type Natural = crate::natural::StartupMode;
    }

    /// The wire type corresponding to [`OnTerminate`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct OnTerminate {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for OnTerminate {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OnTerminate {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl OnTerminate {
        pub const NONE: OnTerminate = OnTerminate { value: ::fidl_next::wire::Uint32(0) };

        pub const REBOOT: OnTerminate = OnTerminate { value: ::fidl_next::wire::Uint32(1) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for OnTerminate
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::OnTerminate> for OnTerminate {
        fn from(natural: crate::natural::OnTerminate) -> Self {
            match natural {
                crate::natural::OnTerminate::None => OnTerminate::NONE,

                crate::natural::OnTerminate::Reboot => OnTerminate::REBOOT,
            }
        }
    }

    impl ::fidl_next::IntoNatural for OnTerminate {
        type Natural = crate::natural::OnTerminate;
    }

    /// The wire type corresponding to [`ConfigKey`](crate::natural::ConfigKey).
    pub type ConfigKey<'de> = ::fidl_next::wire::String<'de>;

    /// The wire type corresponding to [`ConfigOverride`].
    #[repr(C)]
    pub struct ConfigOverride<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigOverride<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigValue<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ConfigOverride<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigOverride<'static> {
        type Narrowed<'de> = ConfigOverride<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigOverride<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 64)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 64 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 64,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigValue<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigOverride<'de> {
        pub fn key(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn value(&self) -> ::core::option::Option<&crate::wire::ConfigValue<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigOverride<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigOverride")
                .field("key", &self.key())
                .field("value", &self.value())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigOverride<'de> {
        type Natural = crate::natural::ConfigOverride;
    }

    /// The wire type corresponding to [`Child`].
    #[repr(C)]
    pub struct Child<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Child<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::StartupMode>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::OnTerminate>() });

            let _ = self.table.get(6)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigOverride<'de>>>()
                });
        }
    }

    impl ::fidl_next::Constrained for Child<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Child<'static> {
        type Narrowed<'de> = Child<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Child<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 4096)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 4096 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 4096,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::StartupMode>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::OnTerminate>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::ConfigOverride<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Child<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn url(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn startup(&self) -> ::core::option::Option<&crate::wire::StartupMode> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn environment(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn on_terminate(&self) -> ::core::option::Option<&crate::wire::OnTerminate> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn config_overrides(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::ConfigOverride<'de>>>
        {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Child<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Child<'de> {
        type Natural = crate::natural::Child;
    }

    /// The wire type corresponding to [`Durability`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Durability {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for Durability {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Durability {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl Durability {
        pub const TRANSIENT: Durability = Durability { value: ::fidl_next::wire::Uint32(2) };

        pub const SINGLE_RUN: Durability = Durability { value: ::fidl_next::wire::Uint32(3) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for Durability
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::Durability> for Durability {
        fn from(natural: crate::natural::Durability) -> Self {
            match natural {
                crate::natural::Durability::Transient => Durability::TRANSIENT,

                crate::natural::Durability::SingleRun => Durability::SINGLE_RUN,
            }
        }
    }

    impl ::fidl_next::IntoNatural for Durability {
        type Natural = crate::natural::Durability;
    }

    /// The wire type corresponding to [`Collection`].
    #[repr(C)]
    pub struct Collection<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Collection<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Durability>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(4)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::AllowedOffers>() });

            let _ = self.table.get(5).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });

            let _ = self.table.get(6).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
        }
    }

    impl ::fidl_next::Constrained for Collection<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Collection<'static> {
        type Narrowed<'de> = Collection<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Collection<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Durability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::AllowedOffers>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Collection<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn durability(&self) -> ::core::option::Option<&crate::wire::Durability> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn environment(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn allowed_offers(&self) -> ::core::option::Option<&crate::wire::AllowedOffers> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn allow_long_names(&self) -> ::core::option::Option<&bool> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn persistent_storage(&self) -> ::core::option::Option<&bool> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Collection<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Collection<'de> {
        type Natural = crate::natural::Collection;
    }

    /// The wire type corresponding to [`DependencyType`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct DependencyType {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for DependencyType {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DependencyType {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl DependencyType {
        pub const STRONG: DependencyType = DependencyType { value: ::fidl_next::wire::Uint32(1) };

        pub const WEAK: DependencyType = DependencyType { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for DependencyType
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::DependencyType> for DependencyType {
        fn from(natural: crate::natural::DependencyType) -> Self {
            match natural {
                crate::natural::DependencyType::Strong => DependencyType::STRONG,

                crate::natural::DependencyType::Weak => DependencyType::WEAK,
            }
        }
    }

    impl ::fidl_next::IntoNatural for DependencyType {
        type Natural = crate::natural::DependencyType;
    }

    /// The wire type corresponding to [`NameMapping`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct NameMapping<'de> {
        pub source_name: ::fidl_next::wire::String<'de>,

        pub target_name: ::fidl_next::wire::String<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<NameMapping<'_>>(), 32);
    static_assertions::const_assert_eq!(std::mem::align_of::<NameMapping<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(NameMapping<'_>, source_name), 0);

    static_assertions::const_assert_eq!(std::mem::offset_of!(NameMapping<'_>, target_name), 16);

    impl ::fidl_next::Constrained for NameMapping<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for NameMapping<'static> {
        type Narrowed<'de> = NameMapping<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    source_name,
                    target_name,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(source_name);

            ::fidl_next::Wire::zero_padding(target_name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NameMapping<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut source_name,
                    mut target_name,

                } = slot_;
            }

            let _field = source_name.as_mut();
            ::fidl_next::Constrained::validate(_field, 100)?;
            ::fidl_next::Decode::decode(source_name.as_mut(), decoder_, 100)?;

            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,
                });
            }

            let _field = target_name.as_mut();
            ::fidl_next::Constrained::validate(_field, 100)?;
            ::fidl_next::Decode::decode(target_name.as_mut(), decoder_, 100)?;

            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(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for NameMapping<'de> {
        type Natural = crate::natural::NameMapping;
    }

    /// The wire type corresponding to [`EnvironmentExtends`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct EnvironmentExtends {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for EnvironmentExtends {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for EnvironmentExtends {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl EnvironmentExtends {
        pub const NONE: EnvironmentExtends =
            EnvironmentExtends { value: ::fidl_next::wire::Uint32(0) };

        pub const REALM: EnvironmentExtends =
            EnvironmentExtends { value: ::fidl_next::wire::Uint32(1) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for EnvironmentExtends
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::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<crate::natural::EnvironmentExtends> for EnvironmentExtends {
        fn from(natural: crate::natural::EnvironmentExtends) -> Self {
            match natural {
                crate::natural::EnvironmentExtends::None => EnvironmentExtends::NONE,

                crate::natural::EnvironmentExtends::Realm => EnvironmentExtends::REALM,
            }
        }
    }

    impl ::fidl_next::IntoNatural for EnvironmentExtends {
        type Natural = crate::natural::EnvironmentExtends;
    }

    /// The wire type corresponding to [`UrlScheme`](crate::natural::UrlScheme).
    pub type UrlScheme<'de> = ::fidl_next::wire::String<'de>;

    /// The wire type corresponding to [`ConfigTypeLayout`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ConfigTypeLayout {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for ConfigTypeLayout {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigTypeLayout {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl ConfigTypeLayout {
        pub const BOOL: ConfigTypeLayout = ConfigTypeLayout { value: ::fidl_next::wire::Uint32(1) };

        pub const UINT8: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(2) };

        pub const UINT16: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(3) };

        pub const UINT32: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(4) };

        pub const UINT64: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(5) };

        pub const INT8: ConfigTypeLayout = ConfigTypeLayout { value: ::fidl_next::wire::Uint32(6) };

        pub const INT16: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(7) };

        pub const INT32: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(8) };

        pub const INT64: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(9) };

        pub const STRING: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(10) };

        pub const VECTOR: ConfigTypeLayout =
            ConfigTypeLayout { value: ::fidl_next::wire::Uint32(11) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for ConfigTypeLayout
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::ConfigTypeLayout> for ConfigTypeLayout {
        fn from(natural: crate::natural::ConfigTypeLayout) -> Self {
            match natural {
                crate::natural::ConfigTypeLayout::Bool => ConfigTypeLayout::BOOL,

                crate::natural::ConfigTypeLayout::Uint8 => ConfigTypeLayout::UINT8,

                crate::natural::ConfigTypeLayout::Uint16 => ConfigTypeLayout::UINT16,

                crate::natural::ConfigTypeLayout::Uint32 => ConfigTypeLayout::UINT32,

                crate::natural::ConfigTypeLayout::Uint64 => ConfigTypeLayout::UINT64,

                crate::natural::ConfigTypeLayout::Int8 => ConfigTypeLayout::INT8,

                crate::natural::ConfigTypeLayout::Int16 => ConfigTypeLayout::INT16,

                crate::natural::ConfigTypeLayout::Int32 => ConfigTypeLayout::INT32,

                crate::natural::ConfigTypeLayout::Int64 => ConfigTypeLayout::INT64,

                crate::natural::ConfigTypeLayout::String => ConfigTypeLayout::STRING,

                crate::natural::ConfigTypeLayout::Vector => ConfigTypeLayout::VECTOR,

                crate::natural::ConfigTypeLayout::UnknownOrdinal_(value) => {
                    ConfigTypeLayout { value: ::fidl_next::wire::Uint32::from(value) }
                }
            }
        }
    }

    impl ::fidl_next::IntoNatural for ConfigTypeLayout {
        type Natural = crate::natural::ConfigTypeLayout;
    }

    /// The wire type corresponding to [`LayoutConstraint`].
    #[repr(transparent)]
    pub struct LayoutConstraint<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for LayoutConstraint<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint32>() };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for LayoutConstraint<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for LayoutConstraint<'static> {
        type Narrowed<'de> = LayoutConstraint<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod layout_constraint {
        pub enum Ref<'de> {
            MaxSize(&'de ::fidl_next::wire::Uint32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> LayoutConstraint<'de> {
        pub fn as_ref(&self) -> crate::wire::layout_constraint::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::layout_constraint::Ref::MaxSize(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>()
                }),

                unknown => crate::wire::layout_constraint::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LayoutConstraint<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for LayoutConstraint<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::Uint32>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for LayoutConstraint<'de> {
        type Natural = crate::natural::LayoutConstraint;
    }

    /// The wire type corresponding to [`ConfigType`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ConfigType<'de> {
        pub layout: crate::wire::ConfigTypeLayout,

        pub parameters: ::fidl_next::wire::OptionalVector<'de, crate::wire::LayoutParameter<'de>>,

        pub constraints: ::fidl_next::wire::Vector<'de, crate::wire::LayoutConstraint<'de>>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<ConfigType<'_>>(), 40);
    static_assertions::const_assert_eq!(std::mem::align_of::<ConfigType<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ConfigType<'_>, layout), 0);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ConfigType<'_>, parameters), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ConfigType<'_>, constraints), 24);

    impl ::fidl_next::Constrained for ConfigType<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigType<'static> {
        type Narrowed<'de> = ConfigType<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    layout,
                    parameters,
                    constraints,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(layout);

            ::fidl_next::Wire::zero_padding(parameters);

            ::fidl_next::Wire::zero_padding(constraints);

            unsafe {
                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigType<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            if slot_.as_bytes()[4..8] != [0u8; 4] {
                return Err(::fidl_next::DecodeError::InvalidPadding);
            }

            ::fidl_next::munge! {
                let Self {
                    mut layout,
                    mut parameters,
                    mut constraints,

                } = slot_;
            }

            let _field = layout.as_mut();

            ::fidl_next::Decode::decode(layout.as_mut(), decoder_, ())?;

            let _field = parameters.as_mut();
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
            ::fidl_next::Decode::decode(parameters.as_mut(), decoder_, (4294967295, ()))?;

            let _field = constraints.as_mut();
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
            ::fidl_next::Decode::decode(constraints.as_mut(), decoder_, (4294967295, ()))?;

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigType<'de> {
        type Natural = crate::natural::ConfigType;
    }

    /// The wire type corresponding to [`ConfigChecksum`].
    #[repr(transparent)]
    pub struct ConfigChecksum<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for ConfigChecksum<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<[u8; 32]>() };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for ConfigChecksum<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigChecksum<'static> {
        type Narrowed<'de> = ConfigChecksum<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod config_checksum {
        pub enum Ref<'de> {
            Sha256(&'de [u8; 32]),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> ConfigChecksum<'de> {
        pub fn as_ref(&self) -> crate::wire::config_checksum::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::config_checksum::Ref::Sha256(unsafe {
                    self.raw.get().deref_unchecked::<[u8; 32]>()
                }),

                unknown => crate::wire::config_checksum::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigChecksum<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, [u8; 32]>(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigChecksum<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe { self.raw.get().deref_unchecked::<[u8; 32]>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigChecksum<'de> {
        type Natural = crate::natural::ConfigChecksum;
    }

    /// The wire type corresponding to [`UseStorage`].
    #[repr(C)]
    pub struct UseStorage<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseStorage<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });
        }
    }

    impl ::fidl_next::Constrained for UseStorage<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseStorage<'static> {
        type Narrowed<'de> = UseStorage<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseStorage<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseStorage<'de> {
        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseStorage<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseStorage<'de> {
        type Natural = crate::natural::UseStorage;
    }

    /// The wire type corresponding to [`ConfigMutability`](crate::natural::ConfigMutability).
    #[derive(Clone, Copy, Debug)]
    #[repr(transparent)]
    pub struct ConfigMutability {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

    impl ::fidl_next::Constrained for ConfigMutability {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigMutability {
        type Narrowed<'de> = Self;

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire bits have no padding
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for ConfigMutability
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::ConfigMutability> for ConfigMutability {
        fn from(natural: crate::natural::ConfigMutability) -> Self {
            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
        }
    }

    impl ::fidl_next::IntoNatural for ConfigMutability {
        type Natural = crate::natural::ConfigMutability;
    }

    /// The wire type corresponding to [`ConfigField`].
    #[repr(C)]
    pub struct ConfigField<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigField<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigType<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigMutability>()
            });
        }
    }

    impl ::fidl_next::Constrained for ConfigField<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigField<'static> {
        type Narrowed<'de> = ConfigField<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigField<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 64)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 64 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 64,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::ConfigType<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigMutability,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigField<'de> {
        pub fn key(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn type_(&self) -> ::core::option::Option<&crate::wire::ConfigType<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn mutability(&self) -> ::core::option::Option<&crate::wire::ConfigMutability> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigField<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigField")
                .field("key", &self.key())
                .field("type_", &self.type_())
                .field("mutability", &self.mutability())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigField<'de> {
        type Natural = crate::natural::ConfigField;
    }

    /// The wire type corresponding to [`Program`].
    #[repr(C)]
    pub struct Program<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Program<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Program<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Program<'static> {
        type Narrowed<'de> = Program<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Program<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_data::wire::Dictionary<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Program<'de> {
        pub fn runner(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn info(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>
        {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Program<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("Program")
                .field("runner", &self.runner())
                .field("info", &self.info())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Program<'de> {
        type Natural = crate::natural::Program;
    }

    /// The wire type corresponding to [`DebugInfo`].
    #[repr(C)]
    pub struct DebugInfo<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for DebugInfo<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
                });
        }
    }

    impl ::fidl_next::Constrained for DebugInfo<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DebugInfo<'static> {
        type Narrowed<'de> = DebugInfo<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugInfo<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, 4294967295))?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> DebugInfo<'de> {
        pub fn manifest_sources(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>
        {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for DebugInfo<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("DebugInfo").field("manifest_sources", &self.manifest_sources()).finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for DebugInfo<'de> {
        type Natural = crate::natural::DebugInfo;
    }

    /// The wire type corresponding to [`UseService`].
    #[repr(C)]
    pub struct UseService<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseService<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseService<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseService<'static> {
        type Narrowed<'de> = UseService<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseService<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseService<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseService<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseService<'de> {
        type Natural = crate::natural::UseService;
    }

    /// The wire type corresponding to [`UseProtocol`].
    #[repr(C)]
    pub struct UseProtocol<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseProtocol<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(7).map(|envelope| unsafe { envelope.read_unchecked::<u8>() });
        }
    }

    impl ::fidl_next::Constrained for UseProtocol<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseProtocol<'static> {
        type Narrowed<'de> = UseProtocol<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseProtocol<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, u8>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseProtocol<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn numbered_handle(&self) -> ::core::option::Option<&u8> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseProtocol<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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())
                .field("numbered_handle", &self.numbered_handle())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseProtocol<'de> {
        type Natural = crate::natural::UseProtocol;
    }

    /// The wire type corresponding to [`UseDirectory`].
    #[repr(C)]
    pub struct UseDirectory<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseDirectory<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(7)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(8).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseDirectory<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseDirectory<'static> {
        type Narrowed<'de> = UseDirectory<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseDirectory<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_io::wire::Operations,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseDirectory<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn rights(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_io::wire::Operations> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseDirectory<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseDirectory<'de> {
        type Natural = crate::natural::UseDirectory;
    }

    /// The wire type corresponding to [`UseEventStream`].
    #[repr(C)]
    pub struct UseEventStream<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseEventStream<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseEventStream<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseEventStream<'static> {
        type Narrowed<'de> = UseEventStream<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseEventStream<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_data::wire::Dictionary<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseEventStream<'de> {
        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn scope(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>
        {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn filter(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>
        {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseEventStream<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseEventStream<'de> {
        type Natural = crate::natural::UseEventStream;
    }

    /// The wire type corresponding to [`UseRunner`].
    #[repr(C)]
    pub struct UseRunner<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseRunner<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseRunner<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseRunner<'static> {
        type Narrowed<'de> = UseRunner<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseRunner<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseRunner<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseRunner<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseRunner<'de> {
        type Natural = crate::natural::UseRunner;
    }

    /// The wire type corresponding to [`UseConfiguration`].
    #[repr(C)]
    pub struct UseConfiguration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseConfiguration<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(4)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigType<'de>>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigValue<'de>>()
            });

            let _ = self.table.get(7).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseConfiguration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseConfiguration<'static> {
        type Narrowed<'de> = UseConfiguration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseConfiguration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::ConfigType<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigValue<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseConfiguration<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn type_(&self) -> ::core::option::Option<&crate::wire::ConfigType<'de>> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn default(&self) -> ::core::option::Option<&crate::wire::ConfigValue<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseConfiguration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseConfiguration<'de> {
        type Natural = crate::natural::UseConfiguration;
    }

    /// The wire type corresponding to [`UseDictionary`].
    #[repr(C)]
    pub struct UseDictionary<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for UseDictionary<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(7)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(8).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for UseDictionary<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for UseDictionary<'static> {
        type Narrowed<'de> = UseDictionary<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UseDictionary<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UseDictionary<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UseDictionary<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UseDictionary")
                .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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UseDictionary<'de> {
        type Natural = crate::natural::UseDictionary;
    }

    /// The wire type corresponding to [`Use`].
    #[repr(transparent)]
    pub struct Use<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for Use<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::UseService<'de>>() };
                }

                2 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::UseProtocol<'de>>() };
                }

                3 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::UseDirectory<'de>>()
                    };
                }

                4 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::UseStorage<'de>>() };
                }

                7 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::UseEventStream<'de>>()
                    };
                }

                8 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::UseRunner<'de>>() };
                }

                9 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::UseConfiguration<'de>>()
                    };
                }

                10 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::UseDictionary<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for Use<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Use<'static> {
        type Narrowed<'de> = Use<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod use_ {
        pub enum Ref<'de> {
            Service(&'de crate::wire::UseService<'de>),

            Protocol(&'de crate::wire::UseProtocol<'de>),

            Directory(&'de crate::wire::UseDirectory<'de>),

            Storage(&'de crate::wire::UseStorage<'de>),

            EventStream(&'de crate::wire::UseEventStream<'de>),

            Runner(&'de crate::wire::UseRunner<'de>),

            Config(&'de crate::wire::UseConfiguration<'de>),

            Dictionary(&'de crate::wire::UseDictionary<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> Use<'de> {
        pub fn as_ref(&self) -> crate::wire::use_::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::use_::Ref::Service(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseService<'_>>()
                }),

                2 => crate::wire::use_::Ref::Protocol(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseProtocol<'_>>()
                }),

                3 => crate::wire::use_::Ref::Directory(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseDirectory<'_>>()
                }),

                4 => crate::wire::use_::Ref::Storage(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseStorage<'_>>()
                }),

                7 => crate::wire::use_::Ref::EventStream(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseEventStream<'_>>()
                }),

                8 => crate::wire::use_::Ref::Runner(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseRunner<'_>>()
                }),

                9 => crate::wire::use_::Ref::Config(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseConfiguration<'_>>()
                }),

                10 => crate::wire::use_::Ref::Dictionary(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseDictionary<'_>>()
                }),

                unknown => crate::wire::use_::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Use<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseDirectory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseStorage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseEventStream<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseConfiguration<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                10 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseDictionary<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Use<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseService<'_>>().fmt(f)
                },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseProtocol<'_>>().fmt(f)
                },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseDirectory<'_>>().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseStorage<'_>>().fmt(f)
                },
                7 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseEventStream<'_>>().fmt(f)
                },
                8 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseRunner<'_>>().fmt(f)
                },
                9 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseConfiguration<'_>>().fmt(f)
                },
                10 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::UseDictionary<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Use<'de> {
        type Natural = crate::natural::Use;
    }

    /// The wire type corresponding to [`ExposeService`].
    #[repr(C)]
    pub struct ExposeService<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeService<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeService<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeService<'static> {
        type Narrowed<'de> = ExposeService<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeService<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeService<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeService<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeService<'de> {
        type Natural = crate::natural::ExposeService;
    }

    /// The wire type corresponding to [`ExposeProtocol`].
    #[repr(C)]
    pub struct ExposeProtocol<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeProtocol<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeProtocol<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeProtocol<'static> {
        type Narrowed<'de> = ExposeProtocol<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeProtocol<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeProtocol<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeProtocol<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeProtocol<'de> {
        type Natural = crate::natural::ExposeProtocol;
    }

    /// The wire type corresponding to [`ExposeDirectory`].
    #[repr(C)]
    pub struct ExposeDirectory<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeDirectory<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(7)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(8).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeDirectory<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeDirectory<'static> {
        type Narrowed<'de> = ExposeDirectory<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeDirectory<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_io::wire::Operations,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeDirectory<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn rights(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_io::wire::Operations> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeDirectory<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeDirectory<'de> {
        type Natural = crate::natural::ExposeDirectory;
    }

    /// The wire type corresponding to [`ExposeRunner`].
    #[repr(C)]
    pub struct ExposeRunner<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeRunner<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeRunner<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeRunner<'static> {
        type Narrowed<'de> = ExposeRunner<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeRunner<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeRunner<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeRunner<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeRunner<'de> {
        type Natural = crate::natural::ExposeRunner;
    }

    /// The wire type corresponding to [`ExposeResolver`].
    #[repr(C)]
    pub struct ExposeResolver<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeResolver<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeResolver<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeResolver<'static> {
        type Narrowed<'de> = ExposeResolver<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeResolver<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeResolver<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeResolver<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeResolver<'de> {
        type Natural = crate::natural::ExposeResolver;
    }

    /// The wire type corresponding to [`ExposeDictionary`].
    #[repr(C)]
    pub struct ExposeDictionary<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeDictionary<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeDictionary<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeDictionary<'static> {
        type Narrowed<'de> = ExposeDictionary<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeDictionary<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeDictionary<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeDictionary<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeDictionary<'de> {
        type Natural = crate::natural::ExposeDictionary;
    }

    /// The wire type corresponding to [`ExposeConfiguration`].
    #[repr(C)]
    pub struct ExposeConfiguration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ExposeConfiguration<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ExposeConfiguration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ExposeConfiguration<'static> {
        type Narrowed<'de> = ExposeConfiguration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExposeConfiguration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ExposeConfiguration<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ExposeConfiguration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ExposeConfiguration<'de> {
        type Natural = crate::natural::ExposeConfiguration;
    }

    /// The wire type corresponding to [`Expose`].
    #[repr(transparent)]
    pub struct Expose<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for Expose<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeService<'de>>()
                    };
                }

                2 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeProtocol<'de>>()
                    };
                }

                3 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeDirectory<'de>>()
                    };
                }

                4 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeRunner<'de>>()
                    };
                }

                5 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeResolver<'de>>()
                    };
                }

                7 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeDictionary<'de>>()
                    };
                }

                8 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::ExposeConfiguration<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for Expose<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Expose<'static> {
        type Narrowed<'de> = Expose<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod expose {
        pub enum Ref<'de> {
            Service(&'de crate::wire::ExposeService<'de>),

            Protocol(&'de crate::wire::ExposeProtocol<'de>),

            Directory(&'de crate::wire::ExposeDirectory<'de>),

            Runner(&'de crate::wire::ExposeRunner<'de>),

            Resolver(&'de crate::wire::ExposeResolver<'de>),

            Dictionary(&'de crate::wire::ExposeDictionary<'de>),

            Config(&'de crate::wire::ExposeConfiguration<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> Expose<'de> {
        pub fn as_ref(&self) -> crate::wire::expose::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::expose::Ref::Service(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeService<'_>>()
                }),

                2 => crate::wire::expose::Ref::Protocol(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeProtocol<'_>>()
                }),

                3 => crate::wire::expose::Ref::Directory(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeDirectory<'_>>()
                }),

                4 => crate::wire::expose::Ref::Runner(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeRunner<'_>>()
                }),

                5 => crate::wire::expose::Ref::Resolver(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeResolver<'_>>()
                }),

                7 => crate::wire::expose::Ref::Dictionary(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeDictionary<'_>>()
                }),

                8 => crate::wire::expose::Ref::Config(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeConfiguration<'_>>()
                }),

                unknown => crate::wire::expose::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Expose<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeDirectory<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeResolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeDictionary<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                8 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ExposeConfiguration<'de>,
                >(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Expose<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeService<'_>>().fmt(f)
                },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeProtocol<'_>>().fmt(f)
                },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeDirectory<'_>>().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeRunner<'_>>().fmt(f)
                },
                5 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeResolver<'_>>().fmt(f)
                },
                7 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeDictionary<'_>>().fmt(f)
                },
                8 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ExposeConfiguration<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Expose<'de> {
        type Natural = crate::natural::Expose;
    }

    /// The wire type corresponding to [`OfferService`].
    #[repr(C)]
    pub struct OfferService<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferService<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
                });

            let _ = self.table.get(6)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NameMapping<'de>>>()
                });

            let _ = self
                .table
                .get(7)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(8).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(9).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferService<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferService<'static> {
        type Narrowed<'de> = OfferService<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferService<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, 100))?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::NameMapping<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    9 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferService<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn source_instance_filter(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>
        {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn renamed_instances(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NameMapping<'de>>>
        {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferService<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferService<'de> {
        type Natural = crate::natural::OfferService;
    }

    /// The wire type corresponding to [`OfferProtocol`].
    #[repr(C)]
    pub struct OfferProtocol<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferProtocol<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(6)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(7).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferProtocol<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferProtocol<'static> {
        type Narrowed<'de> = OfferProtocol<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferProtocol<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferProtocol<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferProtocol<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferProtocol<'de> {
        type Natural = crate::natural::OfferProtocol;
    }

    /// The wire type corresponding to [`OfferDirectory`].
    #[repr(C)]
    pub struct OfferDirectory<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferDirectory<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_io::wire::Operations>()
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(7).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(8)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(9).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferDirectory<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferDirectory<'static> {
        type Narrowed<'de> = OfferDirectory<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferDirectory<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_io::wire::Operations,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    9 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferDirectory<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn rights(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_io::wire::Operations> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferDirectory<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferDirectory<'de> {
        type Natural = crate::natural::OfferDirectory;
    }

    /// The wire type corresponding to [`OfferStorage`].
    #[repr(C)]
    pub struct OfferStorage<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferStorage<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });
        }
    }

    impl ::fidl_next::Constrained for OfferStorage<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferStorage<'static> {
        type Narrowed<'de> = OfferStorage<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferStorage<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferStorage<'de> {
        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferStorage<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferStorage<'de> {
        type Natural = crate::natural::OfferStorage;
    }

    /// The wire type corresponding to [`OfferRunner`].
    #[repr(C)]
    pub struct OfferRunner<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferRunner<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferRunner<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferRunner<'static> {
        type Narrowed<'de> = OfferRunner<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferRunner<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferRunner<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferRunner<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferRunner<'de> {
        type Natural = crate::natural::OfferRunner;
    }

    /// The wire type corresponding to [`OfferResolver`].
    #[repr(C)]
    pub struct OfferResolver<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferResolver<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferResolver<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferResolver<'static> {
        type Narrowed<'de> = OfferResolver<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferResolver<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferResolver<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferResolver<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferResolver<'de> {
        type Natural = crate::natural::OfferResolver;
    }

    /// The wire type corresponding to [`OfferEventStream`].
    #[repr(C)]
    pub struct OfferEventStream<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferEventStream<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>()
            });

            let _ = self
                .table
                .get(4)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(7)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });
        }
    }

    impl ::fidl_next::Constrained for OfferEventStream<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferEventStream<'static> {
        type Narrowed<'de> = OfferEventStream<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferEventStream<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferEventStream<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn scope(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Ref<'de>>>
        {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferEventStream<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferEventStream<'de> {
        type Natural = crate::natural::OfferEventStream;
    }

    /// The wire type corresponding to [`OfferDictionary`].
    #[repr(C)]
    pub struct OfferDictionary<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferDictionary<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DependencyType>()
            });

            let _ = self
                .table
                .get(6)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(7).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferDictionary<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferDictionary<'static> {
        type Narrowed<'de> = OfferDictionary<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferDictionary<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DependencyType>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferDictionary<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn dependency_type(&self) -> ::core::option::Option<&crate::wire::DependencyType> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferDictionary<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferDictionary<'de> {
        type Natural = crate::natural::OfferDictionary;
    }

    /// The wire type corresponding to [`OfferConfiguration`].
    #[repr(C)]
    pub struct OfferConfiguration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for OfferConfiguration<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(3)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(5)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Availability>() });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for OfferConfiguration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for OfferConfiguration<'static> {
        type Narrowed<'de> = OfferConfiguration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OfferConfiguration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Availability>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 1024)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 1024 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 1024,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> OfferConfiguration<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn availability(&self) -> ::core::option::Option<&crate::wire::Availability> {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn source_dictionary(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for OfferConfiguration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for OfferConfiguration<'de> {
        type Natural = crate::natural::OfferConfiguration;
    }

    /// The wire type corresponding to [`Offer`].
    #[repr(transparent)]
    pub struct Offer<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for Offer<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferService<'de>>()
                    };
                }

                2 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferProtocol<'de>>()
                    };
                }

                3 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferDirectory<'de>>()
                    };
                }

                4 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferStorage<'de>>()
                    };
                }

                5 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::OfferRunner<'de>>() };
                }

                6 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferResolver<'de>>()
                    };
                }

                8 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferEventStream<'de>>()
                    };
                }

                9 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferDictionary<'de>>()
                    };
                }

                10 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<crate::wire::OfferConfiguration<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for Offer<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Offer<'static> {
        type Narrowed<'de> = Offer<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod offer {
        pub enum Ref<'de> {
            Service(&'de crate::wire::OfferService<'de>),

            Protocol(&'de crate::wire::OfferProtocol<'de>),

            Directory(&'de crate::wire::OfferDirectory<'de>),

            Storage(&'de crate::wire::OfferStorage<'de>),

            Runner(&'de crate::wire::OfferRunner<'de>),

            Resolver(&'de crate::wire::OfferResolver<'de>),

            EventStream(&'de crate::wire::OfferEventStream<'de>),

            Dictionary(&'de crate::wire::OfferDictionary<'de>),

            Config(&'de crate::wire::OfferConfiguration<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> Offer<'de> {
        pub fn as_ref(&self) -> crate::wire::offer::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::offer::Ref::Service(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferService<'_>>()
                }),

                2 => crate::wire::offer::Ref::Protocol(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferProtocol<'_>>()
                }),

                3 => crate::wire::offer::Ref::Directory(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferDirectory<'_>>()
                }),

                4 => crate::wire::offer::Ref::Storage(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferStorage<'_>>()
                }),

                5 => crate::wire::offer::Ref::Runner(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferRunner<'_>>()
                }),

                6 => crate::wire::offer::Ref::Resolver(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferResolver<'_>>()
                }),

                8 => crate::wire::offer::Ref::EventStream(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferEventStream<'_>>()
                }),

                9 => crate::wire::offer::Ref::Dictionary(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferDictionary<'_>>()
                }),

                10 => crate::wire::offer::Ref::Config(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferConfiguration<'_>>()
                }),

                unknown => crate::wire::offer::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Offer<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferDirectory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferStorage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferResolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferEventStream<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                9 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferDictionary<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                10 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::OfferConfiguration<'de>,
                >(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Offer<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferService<'_>>().fmt(f)
                },
                2 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferProtocol<'_>>().fmt(f)
                },
                3 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferDirectory<'_>>().fmt(f)
                },
                4 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferStorage<'_>>().fmt(f)
                },
                5 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferRunner<'_>>().fmt(f)
                },
                6 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferResolver<'_>>().fmt(f)
                },
                8 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferEventStream<'_>>().fmt(f)
                },
                9 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferDictionary<'_>>().fmt(f)
                },
                10 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::OfferConfiguration<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Offer<'de> {
        type Natural = crate::natural::Offer;
    }

    /// The wire type corresponding to [`RunnerRegistration`].
    #[repr(C)]
    pub struct RunnerRegistration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for RunnerRegistration<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for RunnerRegistration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for RunnerRegistration<'static> {
        type Narrowed<'de> = RunnerRegistration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RunnerRegistration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> RunnerRegistration<'de> {
        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for RunnerRegistration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for RunnerRegistration<'de> {
        type Natural = crate::natural::RunnerRegistration;
    }

    /// The wire type corresponding to [`ResolverRegistration`].
    #[repr(C)]
    pub struct ResolverRegistration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ResolverRegistration<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self
                .table
                .get(2)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ResolverRegistration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ResolverRegistration<'static> {
        type Narrowed<'de> = ResolverRegistration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolverRegistration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ResolverRegistration<'de> {
        pub fn resolver(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn scheme(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ResolverRegistration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ResolverRegistration")
                .field("resolver", &self.resolver())
                .field("source", &self.source())
                .field("scheme", &self.scheme())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ResolverRegistration<'de> {
        type Natural = crate::natural::ResolverRegistration;
    }

    /// The wire type corresponding to [`DebugProtocolRegistration`].
    #[repr(C)]
    pub struct DebugProtocolRegistration<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for DebugProtocolRegistration<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Ref<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for DebugProtocolRegistration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DebugProtocolRegistration<'static> {
        type Narrowed<'de> = DebugProtocolRegistration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugProtocolRegistration<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Ref<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> DebugProtocolRegistration<'de> {
        pub fn source(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn source_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn target_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for DebugProtocolRegistration<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for DebugProtocolRegistration<'de> {
        type Natural = crate::natural::DebugProtocolRegistration;
    }

    /// The wire type corresponding to [`DebugRegistration`].
    #[repr(transparent)]
    pub struct DebugRegistration<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for DebugRegistration<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw
                            .get()
                            .read_unchecked::<crate::wire::DebugProtocolRegistration<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for DebugRegistration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DebugRegistration<'static> {
        type Narrowed<'de> = DebugRegistration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod debug_registration {
        pub enum Ref<'de> {
            Protocol(&'de crate::wire::DebugProtocolRegistration<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> DebugRegistration<'de> {
        pub fn as_ref(&self) -> crate::wire::debug_registration::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::debug_registration::Ref::Protocol(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::DebugProtocolRegistration<'_>>()
                }),

                unknown => crate::wire::debug_registration::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugRegistration<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::DebugProtocolRegistration<'de>,
                >(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for DebugRegistration<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw
                        .get()
                        .deref_unchecked::<crate::wire::DebugProtocolRegistration<'_>>()
                        .fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for DebugRegistration<'de> {
        type Natural = crate::natural::DebugRegistration;
    }

    /// The wire type corresponding to [`Environment`].
    #[repr(C)]
    pub struct Environment<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Environment<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::EnvironmentExtends>()
            });

            let _ = self.table.get(3)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::RunnerRegistration<'de>>>()
                });

            let _ = self.table.get(4)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ResolverRegistration<'de>>>()
                });

            let _ = self.table.get(5)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DebugRegistration<'de>>>()
                });

            let _ = self
                .table
                .get(6)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
        }
    }

    impl ::fidl_next::Constrained for Environment<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Environment<'static> {
        type Narrowed<'de> = Environment<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Environment<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::EnvironmentExtends,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::RunnerRegistration<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::ResolverRegistration<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::DebugRegistration<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Environment<'de> {
        pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn extends(&self) -> ::core::option::Option<&crate::wire::EnvironmentExtends> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn runners(
            &self,
        ) -> ::core::option::Option<
            &::fidl_next::wire::Vector<'de, crate::wire::RunnerRegistration<'de>>,
        > {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn resolvers(
            &self,
        ) -> ::core::option::Option<
            &::fidl_next::wire::Vector<'de, crate::wire::ResolverRegistration<'de>>,
        > {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn debug_capabilities(
            &self,
        ) -> ::core::option::Option<
            &::fidl_next::wire::Vector<'de, crate::wire::DebugRegistration<'de>>,
        > {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn stop_timeout_ms(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Environment<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Environment<'de> {
        type Natural = crate::natural::Environment;
    }

    /// The wire type corresponding to [`ConfigSourceCapabilities`].
    #[repr(C)]
    pub struct ConfigSourceCapabilities<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigSourceCapabilities<'de> {
        fn drop(&mut self) {}
    }

    impl ::fidl_next::Constrained for ConfigSourceCapabilities<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigSourceCapabilities<'static> {
        type Narrowed<'de> = ConfigSourceCapabilities<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigSourceCapabilities<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigSourceCapabilities<'de> {}

    impl<'de> ::core::fmt::Debug for ConfigSourceCapabilities<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigSourceCapabilities").finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigSourceCapabilities<'de> {
        type Natural = crate::natural::ConfigSourceCapabilities;
    }

    /// The wire type corresponding to [`ConfigValueSource`].
    #[repr(transparent)]
    pub struct ConfigValueSource<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for ConfigValueSource<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe {
                        self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
                    };
                }

                2 => {
                    let _ = unsafe {
                        self.raw
                            .get()
                            .read_unchecked::<crate::wire::ConfigSourceCapabilities<'de>>()
                    };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for ConfigValueSource<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValueSource<'static> {
        type Narrowed<'de> = ConfigValueSource<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod config_value_source {
        pub enum Ref<'de> {
            PackagePath(&'de ::fidl_next::wire::String<'de>),

            Capabilities(&'de crate::wire::ConfigSourceCapabilities<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> ConfigValueSource<'de> {
        pub fn as_ref(&self) -> crate::wire::config_value_source::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::config_value_source::Ref::PackagePath(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
                }),

                2 => crate::wire::config_value_source::Ref::Capabilities(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigSourceCapabilities<'_>>()
                }),

                unknown => crate::wire::config_value_source::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValueSource<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
                    raw, decoder, 4294967295,
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigSourceCapabilities<'de>,
                >(raw, decoder, ())?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValueSource<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
                },
                2 => unsafe {
                    self.raw
                        .get()
                        .deref_unchecked::<crate::wire::ConfigSourceCapabilities<'_>>()
                        .fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValueSource<'de> {
        type Natural = crate::natural::ConfigValueSource;
    }

    /// The wire type corresponding to [`ConfigSchema`].
    #[repr(C)]
    pub struct ConfigSchema<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigSchema<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigField<'de>>>()
                });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigChecksum<'de>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigValueSource<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ConfigSchema<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigSchema<'static> {
        type Narrowed<'de> = ConfigSchema<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigSchema<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::ConfigField<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigChecksum<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigValueSource<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigSchema<'de> {
        pub fn fields(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::ConfigField<'de>>>
        {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn checksum(&self) -> ::core::option::Option<&crate::wire::ConfigChecksum<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn value_source(&self) -> ::core::option::Option<&crate::wire::ConfigValueSource<'de>> {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigSchema<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigSchema")
                .field("fields", &self.fields())
                .field("checksum", &self.checksum())
                .field("value_source", &self.value_source())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigSchema<'de> {
        type Natural = crate::natural::ConfigSchema;
    }

    /// The wire type corresponding to [`Component`].
    #[repr(C)]
    pub struct Component<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for Component<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Program<'de>>() });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Use<'de>>>()
            });

            let _ = self.table.get(3).map(|envelope| unsafe {
                envelope
                    .read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Expose<'de>>>()
            });

            let _ = self.table.get(4).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Offer<'de>>>()
            });

            let _ = self.table.get(5).map(|envelope| unsafe {
                envelope
                    .read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Capability<'de>>>(
                    )
            });

            let _ = self.table.get(6).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Child<'de>>>()
            });

            let _ = self.table.get(7).map(|envelope| unsafe {
                envelope
                    .read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Collection<'de>>>(
                    )
            });

            let _ = self.table.get(8)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Environment<'de>>>()
                });

            let _ = self.table.get(9).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>()
            });

            let _ = self.table.get(10).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigSchema<'de>>()
            });

            let _ = self.table.get(11).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::DebugInfo<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for Component<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Component<'static> {
        type Narrowed<'de> = Component<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Component<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Program<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Use<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    3 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Expose<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    4 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Offer<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    5 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Capability<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    6 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Child<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    7 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Collection<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    8 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::Environment<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    9 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next_common_fuchsia_data::wire::Dictionary<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    10 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigSchema<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    11 => {
                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DebugInfo<'de>>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> Component<'de> {
        pub fn program(&self) -> ::core::option::Option<&crate::wire::Program<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn uses(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Use<'de>>>
        {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }

        pub fn exposes(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Expose<'de>>>
        {
            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
        }

        pub fn offers(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Offer<'de>>>
        {
            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
        }

        pub fn capabilities(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Capability<'de>>>
        {
            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
        }

        pub fn children(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Child<'de>>>
        {
            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
        }

        pub fn collections(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Collection<'de>>>
        {
            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
        }

        pub fn environments(
            &self,
        ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::Environment<'de>>>
        {
            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
        }

        pub fn facets(
            &self,
        ) -> ::core::option::Option<&::fidl_next_common_fuchsia_data::wire::Dictionary<'de>>
        {
            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
        }

        pub fn config(&self) -> ::core::option::Option<&crate::wire::ConfigSchema<'de>> {
            unsafe { Some(self.table.get(10)?.deref_unchecked()) }
        }

        pub fn debug_info(&self) -> ::core::option::Option<&crate::wire::DebugInfo<'de>> {
            unsafe { Some(self.table.get(11)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for Component<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::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())
                .field("debug_info", &self.debug_info())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Component<'de> {
        type Natural = crate::natural::Component;
    }

    /// The wire type corresponding to [`ConfigValueSpec`].
    #[repr(C)]
    pub struct ConfigValueSpec<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigValueSpec<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigValue<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ConfigValueSpec<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValueSpec<'static> {
        type Narrowed<'de> = ConfigValueSpec<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValueSpec<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigValue<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigValueSpec<'de> {
        pub fn value(&self) -> ::core::option::Option<&crate::wire::ConfigValue<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValueSpec<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigValueSpec").field("value", &self.value()).finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValueSpec<'de> {
        type Natural = crate::natural::ConfigValueSpec;
    }

    /// The wire type corresponding to [`ConfigValuesData`].
    #[repr(C)]
    pub struct ConfigValuesData<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for ConfigValuesData<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::ConfigValueSpec<'de>>>()
                });

            let _ = self.table.get(2).map(|envelope| unsafe {
                envelope.read_unchecked::<crate::wire::ConfigChecksum<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for ConfigValuesData<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValuesData<'static> {
        type Narrowed<'de> = ConfigValuesData<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValuesData<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::Vector<'de, crate::wire::ConfigValueSpec<'de>>,
                        >(slot.as_mut(), decoder, (4294967295, ()))?;

                        Ok(())
                    }

                    2 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            crate::wire::ConfigChecksum<'de>,
                        >(slot.as_mut(), decoder, ())?;

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> ConfigValuesData<'de> {
        pub fn values(
            &self,
        ) -> ::core::option::Option<
            &::fidl_next::wire::Vector<'de, crate::wire::ConfigValueSpec<'de>>,
        > {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }

        pub fn checksum(&self) -> ::core::option::Option<&crate::wire::ConfigChecksum<'de>> {
            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValuesData<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("ConfigValuesData")
                .field("values", &self.values())
                .field("checksum", &self.checksum())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValuesData<'de> {
        type Natural = crate::natural::ConfigValuesData;
    }

    /// The wire type corresponding to [`EventSubscription`].
    #[repr(C)]
    pub struct EventSubscription<'de> {
        pub(crate) table: ::fidl_next::wire::Table<'de>,
    }

    impl<'de> Drop for EventSubscription<'de> {
        fn drop(&mut self) {
            let _ = self.table.get(1).map(|envelope| unsafe {
                envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
            });
        }
    }

    impl ::fidl_next::Constrained for EventSubscription<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for EventSubscription<'static> {
        type Narrowed<'de> = EventSubscription<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::wire::Table::zero_padding(table);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventSubscription<'de>
    where
        ___D: ::fidl_next::Decoder<'de> + ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { table } = slot);

            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::wire::Envelope::decode_as::<
                            ___D,
                            ::fidl_next::wire::String<'de>,
                        >(slot.as_mut(), decoder, 100)?;

                        let value = unsafe {
                            slot.deref_unchecked()
                                .deref_unchecked::<::fidl_next::wire::String<'_>>()
                        };

                        if value.len() > 100 {
                            return Err(::fidl_next::DecodeError::VectorTooLong {
                                size: value.len() as u64,
                                limit: 100,
                            });
                        }

                        Ok(())
                    }

                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> EventSubscription<'de> {
        pub fn event_name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for EventSubscription<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("EventSubscription").field("event_name", &self.event_name()).finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for EventSubscription<'de> {
        type Natural = crate::natural::EventSubscription;
    }

    /// The wire type corresponding to [`LayoutParameter`].
    #[repr(transparent)]
    pub struct LayoutParameter<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for LayoutParameter<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ =
                        unsafe { self.raw.get().read_unchecked::<crate::wire::ConfigType<'de>>() };
                }

                _ => (),
            }
        }
    }

    impl ::fidl_next::Constrained for LayoutParameter<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for LayoutParameter<'static> {
        type Narrowed<'de> = LayoutParameter<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    pub mod layout_parameter {
        pub enum Ref<'de> {
            NestedType(&'de crate::wire::ConfigType<'de>),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> LayoutParameter<'de> {
        pub fn as_ref(&self) -> crate::wire::layout_parameter::Ref<'_> {
            match self.raw.ordinal() {
                1 => crate::wire::layout_parameter::Ref::NestedType(unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigType<'_>>()
                }),

                unknown => crate::wire::layout_parameter::Ref::UnknownOrdinal_(unknown),
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LayoutParameter<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ConfigType<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for LayoutParameter<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            match self.raw.ordinal() {
                1 => unsafe {
                    self.raw.get().deref_unchecked::<crate::wire::ConfigType<'_>>().fmt(f)
                },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for LayoutParameter<'de> {
        type Natural = crate::natural::LayoutParameter;
    }

    /// The wire type corresponding to [`ResolvedConfigField`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ResolvedConfigField<'de> {
        pub key: ::fidl_next::wire::String<'de>,

        pub value: crate::wire::ConfigValue<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<ResolvedConfigField<'_>>(), 32);
    static_assertions::const_assert_eq!(std::mem::align_of::<ResolvedConfigField<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ResolvedConfigField<'_>, key), 0);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ResolvedConfigField<'_>, value), 16);

    impl ::fidl_next::Constrained for ResolvedConfigField<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ResolvedConfigField<'static> {
        type Narrowed<'de> = ResolvedConfigField<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    key,
                    value,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(key);

            ::fidl_next::Wire::zero_padding(value);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolvedConfigField<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut key,
                    mut value,

                } = slot_;
            }

            let _field = key.as_mut();
            ::fidl_next::Constrained::validate(_field, 4294967295)?;
            ::fidl_next::Decode::decode(key.as_mut(), decoder_, 4294967295)?;

            let _field = value.as_mut();

            ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ResolvedConfigField<'de> {
        type Natural = crate::natural::ResolvedConfigField;
    }

    /// The wire type corresponding to [`ResolvedConfig`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ResolvedConfig<'de> {
        pub fields: ::fidl_next::wire::Vector<'de, crate::wire::ResolvedConfigField<'de>>,

        pub checksum: crate::wire::ConfigChecksum<'de>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<ResolvedConfig<'_>>(), 32);
    static_assertions::const_assert_eq!(std::mem::align_of::<ResolvedConfig<'_>>(), 8);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ResolvedConfig<'_>, fields), 0);

    static_assertions::const_assert_eq!(std::mem::offset_of!(ResolvedConfig<'_>, checksum), 16);

    impl ::fidl_next::Constrained for ResolvedConfig<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ResolvedConfig<'static> {
        type Narrowed<'de> = ResolvedConfig<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    fields,
                    checksum,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(fields);

            ::fidl_next::Wire::zero_padding(checksum);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolvedConfig<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut fields,
                    mut checksum,

                } = slot_;
            }

            let _field = fields.as_mut();
            ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
            ::fidl_next::Decode::decode(fields.as_mut(), decoder_, (4294967295, ()))?;

            let _field = checksum.as_mut();

            ::fidl_next::Decode::decode(checksum.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ResolvedConfig<'de> {
        type Natural = crate::natural::ResolvedConfig;
    }
}

pub mod wire_optional {

    #[repr(transparent)]
    pub struct ConfigSingleValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for ConfigSingleValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigSingleValue<'static> {
        type Narrowed<'de> = ConfigSingleValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> ConfigSingleValue<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConfigSingleValue<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::ConfigSingleValue<'de>> {
            if self.is_some() {
                Some(crate::wire::ConfigSingleValue {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigSingleValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, bool>(raw, decoder, ())?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, u8>(raw, decoder, ())?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint16>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, i8>(raw, decoder, ())?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int16>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int32>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
                    raw,
                    decoder,
                    (),
                )?,

                10 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
                    raw, decoder, 4294967295,
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigSingleValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigSingleValue<'de> {
        type Natural = ::core::option::Option<crate::natural::ConfigSingleValue>;
    }

    #[repr(transparent)]
    pub struct ConfigVectorValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for ConfigVectorValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigVectorValue<'static> {
        type Narrowed<'de> = ConfigVectorValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> ConfigVectorValue<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConfigVectorValue<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::ConfigVectorValue<'de>> {
            if self.is_some() {
                Some(crate::wire::ConfigVectorValue {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigVectorValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, bool>,
                >(raw, decoder, (4294967295, ()))?,

                2 => {
                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
                        raw,
                        decoder,
                        (4294967295, ()),
                    )?
                }

                3 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint16>,
                >(raw, decoder, (4294967295, ()))?,

                4 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint32>,
                >(raw, decoder, (4294967295, ()))?,

                5 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Uint64>,
                >(raw, decoder, (4294967295, ()))?,

                6 => {
                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, i8>>(
                        raw,
                        decoder,
                        (4294967295, ()),
                    )?
                }

                7 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int16>,
                >(raw, decoder, (4294967295, ()))?,

                8 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int32>,
                >(raw, decoder, (4294967295, ()))?,

                9 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Int64>,
                >(raw, decoder, (4294967295, ()))?,

                10 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
                >(raw, decoder, (4294967295, 4294967295))?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigVectorValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigVectorValue<'de> {
        type Natural = ::core::option::Option<crate::natural::ConfigVectorValue>;
    }

    #[repr(transparent)]
    pub struct ConfigValue<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for ConfigValue<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValue<'static> {
        type Narrowed<'de> = ConfigValue<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> ConfigValue<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConfigValue<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::ConfigValue<'de>> {
            if self.is_some() {
                Some(crate::wire::ConfigValue {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValue<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigSingleValue<'de>,
                >(raw, decoder, ())?,

                2 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigVectorValue<'de>,
                >(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValue<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValue<'de> {
        type Natural = ::core::option::Option<crate::natural::ConfigValue>;
    }

    #[repr(transparent)]
    pub struct Ref<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for Ref<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Ref<'static> {
        type Narrowed<'de> = Ref<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> Ref<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Ref<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::Ref<'de>> {
            if self.is_some() {
                Some(crate::wire::Ref { raw: self.raw, _phantom: ::core::marker::PhantomData })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Ref<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ParentRef>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SelfRef>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ChildRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::CollectionRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FrameworkRef>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::CapabilityRef<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DebugRef>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::VoidRef>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EnvironmentRef>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Ref<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Ref<'de> {
        type Natural = ::core::option::Option<crate::natural::Ref>;
    }

    #[repr(transparent)]
    pub struct Capability<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for Capability<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Capability<'static> {
        type Narrowed<'de> = Capability<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> Capability<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
            if self.is_some() {
                Some(crate::wire::Capability {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Protocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Directory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Storage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Runner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Resolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EventStream<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Dictionary<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                10 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Configuration<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Capability<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
        type Natural = ::core::option::Option<crate::natural::Capability>;
    }

    #[repr(transparent)]
    pub struct LayoutConstraint<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for LayoutConstraint<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for LayoutConstraint<'static> {
        type Narrowed<'de> = LayoutConstraint<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> LayoutConstraint<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::LayoutConstraint<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::LayoutConstraint<'de>> {
            if self.is_some() {
                Some(crate::wire::LayoutConstraint {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LayoutConstraint<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for LayoutConstraint<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for LayoutConstraint<'de> {
        type Natural = ::core::option::Option<crate::natural::LayoutConstraint>;
    }

    #[repr(transparent)]
    pub struct ConfigChecksum<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for ConfigChecksum<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigChecksum<'static> {
        type Narrowed<'de> = ConfigChecksum<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> ConfigChecksum<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConfigChecksum<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::ConfigChecksum<'de>> {
            if self.is_some() {
                Some(crate::wire::ConfigChecksum {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigChecksum<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, [u8; 32]>(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigChecksum<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigChecksum<'de> {
        type Natural = ::core::option::Option<crate::natural::ConfigChecksum>;
    }

    #[repr(transparent)]
    pub struct Use<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for Use<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Use<'static> {
        type Narrowed<'de> = Use<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> Use<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Use<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::Use<'de>> {
            if self.is_some() {
                Some(crate::wire::Use { raw: self.raw, _phantom: ::core::marker::PhantomData })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Use<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseDirectory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseStorage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseEventStream<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                9 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseConfiguration<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                10 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::UseDictionary<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Use<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Use<'de> {
        type Natural = ::core::option::Option<crate::natural::Use>;
    }

    #[repr(transparent)]
    pub struct Expose<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for Expose<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Expose<'static> {
        type Narrowed<'de> = Expose<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> Expose<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Expose<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::Expose<'de>> {
            if self.is_some() {
                Some(crate::wire::Expose { raw: self.raw, _phantom: ::core::marker::PhantomData })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Expose<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeDirectory<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeResolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                7 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ExposeDictionary<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                8 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ExposeConfiguration<'de>,
                >(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Expose<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Expose<'de> {
        type Natural = ::core::option::Option<crate::natural::Expose>;
    }

    #[repr(transparent)]
    pub struct Offer<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for Offer<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for Offer<'static> {
        type Narrowed<'de> = Offer<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> Offer<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Offer<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::Offer<'de>> {
            if self.is_some() {
                Some(crate::wire::Offer { raw: self.raw, _phantom: ::core::marker::PhantomData })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Offer<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferService<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferProtocol<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferDirectory<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferStorage<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferRunner<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferResolver<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                8 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferEventStream<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                9 => {
                    ::fidl_next::wire::Union::decode_as::<___D, crate::wire::OfferDictionary<'de>>(
                        raw,
                        decoder,
                        (),
                    )?
                }

                10 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::OfferConfiguration<'de>,
                >(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for Offer<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for Offer<'de> {
        type Natural = ::core::option::Option<crate::natural::Offer>;
    }

    #[repr(transparent)]
    pub struct DebugRegistration<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for DebugRegistration<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DebugRegistration<'static> {
        type Narrowed<'de> = DebugRegistration<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> DebugRegistration<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DebugRegistration<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::DebugRegistration<'de>> {
            if self.is_some() {
                Some(crate::wire::DebugRegistration {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugRegistration<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::DebugProtocolRegistration<'de>,
                >(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for DebugRegistration<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for DebugRegistration<'de> {
        type Natural = ::core::option::Option<crate::natural::DebugRegistration>;
    }

    #[repr(transparent)]
    pub struct ConfigValueSource<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for ConfigValueSource<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for ConfigValueSource<'static> {
        type Narrowed<'de> = ConfigValueSource<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> ConfigValueSource<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConfigValueSource<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::ConfigValueSource<'de>> {
            if self.is_some() {
                Some(crate::wire::ConfigValueSource {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConfigValueSource<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
                    raw, decoder, 4294967295,
                )?,

                2 => ::fidl_next::wire::Union::decode_as::<
                    ___D,
                    crate::wire::ConfigSourceCapabilities<'de>,
                >(raw, decoder, ())?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for ConfigValueSource<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for ConfigValueSource<'de> {
        type Natural = ::core::option::Option<crate::natural::ConfigValueSource>;
    }

    #[repr(transparent)]
    pub struct LayoutParameter<'de> {
        pub(crate) raw: ::fidl_next::wire::Union,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl ::fidl_next::Constrained for LayoutParameter<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for LayoutParameter<'static> {
        type Narrowed<'de> = LayoutParameter<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::wire::Union::zero_padding(raw);
        }
    }

    impl<'de> LayoutParameter<'de> {
        pub fn is_some(&self) -> bool {
            self.raw.is_some()
        }

        pub fn is_none(&self) -> bool {
            self.raw.is_none()
        }

        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::LayoutParameter<'de>> {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(self) -> ::core::option::Option<crate::wire::LayoutParameter<'de>> {
            if self.is_some() {
                Some(crate::wire::LayoutParameter {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LayoutParameter<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            mut slot: ::fidl_next::Slot<'_, Self>,
            decoder: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ConfigType<'de>>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for LayoutParameter<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for LayoutParameter<'de> {
        type Natural = ::core::option::Option<crate::natural::LayoutParameter>;
    }
}

pub mod generic {

    /// The generic type corresponding to [`ParentRef`].
    pub type ParentRef = ();

    /// The generic type corresponding to [`SelfRef`].
    pub type SelfRef = ();

    /// The generic type corresponding to [`ChildRef`].
    pub struct ChildRef<T0, T1> {
        pub name: T0,

        pub collection: T1,
    }

    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ChildRef<'static>, ___E>
        for ChildRef<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
        T1: ::fidl_next::Encode<::fidl_next::wire::OptionalString<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ChildRef {
                    name,
                    collection,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.name, encoder_, name, 1024)?;

            ::fidl_next::Encode::encode(self.collection, encoder_, collection, 100)?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`CollectionRef`].
    pub struct CollectionRef<T0> {
        pub name: T0,
    }

    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CollectionRef<'static>, ___E>
        for CollectionRef<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CollectionRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CollectionRef {
                    name,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.name, encoder_, name, 100)?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`FrameworkRef`].
    pub type FrameworkRef = ();

    /// The generic type corresponding to [`CapabilityRef`].
    pub struct CapabilityRef<T0> {
        pub name: T0,
    }

    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CapabilityRef<'static>, ___E>
        for CapabilityRef<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRef<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::CapabilityRef {
                    name,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.name, encoder_, name, 100)?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`DebugRef`].
    pub type DebugRef = ();

    /// The generic type corresponding to [`VoidRef`].
    pub type VoidRef = ();

    /// The generic type corresponding to [`EnvironmentRef`].
    pub type EnvironmentRef = ();

    /// The generic type corresponding to [`NameMapping`].
    pub struct NameMapping<T0, T1> {
        pub source_name: T0,

        pub target_name: T1,
    }

    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NameMapping<'static>, ___E>
        for NameMapping<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
        T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::NameMapping<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::NameMapping {
                    source_name,
                    target_name,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.source_name, encoder_, source_name, 100)?;

            ::fidl_next::Encode::encode(self.target_name, encoder_, target_name, 100)?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`ConfigType`].
    pub struct ConfigType<T0, T1, T2> {
        pub layout: T0,

        pub parameters: T1,

        pub constraints: T2,
    }

    unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::ConfigType<'static>, ___E>
        for ConfigType<T0, T1, T2>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<crate::wire::ConfigTypeLayout, ___E>,
        T1: ::fidl_next::Encode<
                ::fidl_next::wire::OptionalVector<'static, crate::wire::LayoutParameter<'static>>,
                ___E,
            >,
        T2: ::fidl_next::Encode<
                ::fidl_next::wire::Vector<'static, crate::wire::LayoutConstraint<'static>>,
                ___E,
            >,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ConfigType<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ConfigType {
                    layout,
                    parameters,
                    constraints,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.layout, encoder_, layout, ())?;

            ::fidl_next::Encode::encode(self.parameters, encoder_, parameters, (4294967295, ()))?;

            ::fidl_next::Encode::encode(self.constraints, encoder_, constraints, (4294967295, ()))?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`ResolvedConfigField`].
    pub struct ResolvedConfigField<T0, T1> {
        pub key: T0,

        pub value: T1,
    }

    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ResolvedConfigField<'static>, ___E>
        for ResolvedConfigField<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
        T1: ::fidl_next::Encode<crate::wire::ConfigValue<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfigField<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfigField {
                    key,
                    value,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.key, encoder_, key, 4294967295)?;

            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`ResolvedConfig`].
    pub struct ResolvedConfig<T0, T1> {
        pub fields: T0,

        pub checksum: T1,
    }

    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::ResolvedConfig<'static>, ___E>
        for ResolvedConfig<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        T0: ::fidl_next::Encode<
                ::fidl_next::wire::Vector<'static, crate::wire::ResolvedConfigField<'static>>,
                ___E,
            >,
        T1: ::fidl_next::Encode<crate::wire::ConfigChecksum<'static>, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedConfig<'static>>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::ResolvedConfig {
                    fields,
                    checksum,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.fields, encoder_, fields, (4294967295, ()))?;

            ::fidl_next::Encode::encode(self.checksum, encoder_, checksum, ())?;

            Ok(())
        }
    }
}

pub use self::natural::*;

#[doc = " Config keys can only consist of these many bytes\n"]
pub const CONFIG_KEY_MAX_SIZE: u32 = 64 as u32;

pub const MAX_NAME_LENGTH: u32 = 100 as u32;

pub const MAX_PATH_LENGTH: u32 = 1024 as u32;

pub const MAX_CHILD_NAME_LENGTH: u32 = 1024 as u32;

pub const MAX_URL_SCHEME_LENGTH: u32 = 100 as u32;

pub const MAX_MONIKER_LENGTH: u32 = 4096 as u32;

#[doc = " The maximum number of EventSubscriptions in an EventStream.\n"]
pub const MAX_NUM_EVENT_STREAM_SUBSCRIPTIONS: u64 = 100 as u64;