tools/fidl/fidlgen_rust_next/goldens/unknown_interactions.rs.golden

// 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 {

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::SomeField(
                    value,
                ) => ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                    value,
                    1,
                    encoder,
                    raw,
                    (),
                )?,

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<
                'de,
            >,
        > for Box<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {

                UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(value, 1, encoder, raw, ())?,


                UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(ordinal) => return Err(
                    ::fidl_next::EncodeError::UnknownUnionOrdinal(
                        *ordinal as usize
                    )
                )

        }

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<
                'de,
            >,
        > for Box<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>,
        > for Box<UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictEventFieldsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest>
        for UnknownInteractionsAjarProtocolStrictEventFieldsRequest
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
        > for UnknownInteractionsAjarProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarProtocolStrictEventUnionRequest {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictEventUnionRequest
    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::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarProtocolStrictEventUnionRequest
    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::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsAjarProtocolStrictEventUnionRequest::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de>,
        > for Box<UnknownInteractionsAjarProtocolStrictEventUnionRequest>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarProtocolStrictEventUnionRequest<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarProtocolStrictEventTableRequest {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
            ___E,
        > for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
        > for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
        > for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsAjarProtocolFlexibleEventUnionRequest {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>,
            ___E,
        > for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest
    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::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>,
            ___E,
        > for &'a UnknownInteractionsAjarProtocolFlexibleEventUnionRequest
    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::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>,
        > for Box<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsAjarProtocolFlexibleEventTableRequest {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {

                UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(value, 1, encoder, raw, ())?,


                UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(ordinal) => return Err(
                    ::fidl_next::EncodeError::UnknownUnionOrdinal(
                        *ordinal as usize
                    )
                )

        }

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<
                'de,
            >,
        > for Box<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        Ok(())
    }
}

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<
                'static,
            >,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<
                'static,
            >,
            ___E,
        > for &'a UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {

                UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(value, 1, encoder, raw, ())?,


                UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(ordinal) => return Err(
                    ::fidl_next::EncodeError::UnknownUnionOrdinal(
                        *ordinal as usize
                    )
                )

        }

            Ok(())
        }
    }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

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

    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>> for Box<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse> {
    #[inline]
    fn from_wire_option_ref(wire: &crate::wire_optional::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<
                'de,
            >,
        > for Box<UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictEventFieldsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
        > for UnknownInteractionsClosedProtocolStrictEventFieldsRequest
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
        > for UnknownInteractionsClosedProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsClosedProtocolStrictEventUnionRequest {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictEventUnionRequest
    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::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for &'a UnknownInteractionsClosedProtocolStrictEventUnionRequest
    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::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsClosedProtocolStrictEventUnionRequest::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>,
        > for Box<UnknownInteractionsClosedProtocolStrictEventUnionRequest>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsClosedProtocolStrictEventUnionRequest<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsClosedProtocolStrictEventTableRequest {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<
                'de,
            >,
        > for Box<UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse
    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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse
    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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse
    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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse
    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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<
                    'static,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {

                UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(value, 1, encoder, raw, ())?,


                UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::UnknownOrdinal_(ordinal) => return Err(
                    ::fidl_next::EncodeError::UnknownUnionOrdinal(
                        *ordinal as usize
                    )
                )

        }

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<
                'de,
            >,
        > for Box<UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>
        for UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>
        for UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolStrictTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolStrictTwoWayUnionResponse
    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::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolStrictTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsProtocolStrictTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolStrictTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::UnknownInteractionsProtocolStrictTwoWayErrResponse, ___E>
        for UnknownInteractionsProtocolStrictTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolStrictTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse>
        for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
        > for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolStrictTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolStrictTwoWayUnionErrResponse
    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::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>,
        > for Box<UnknownInteractionsProtocolStrictTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolStrictTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::UnknownInteractionsProtocolFlexibleTwoWayResponse, ___E>
        for UnknownInteractionsProtocolFlexibleTwoWayResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

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

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse>
        for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolFlexibleTwoWayUnionResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse
    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::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolFlexibleTwoWayUnionResponse
    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::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de>,
        > for Box<UnknownInteractionsProtocolFlexibleTwoWayUnionResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayTableResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

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

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::UnknownInteractionsProtocolFlexibleTwoWayErrResponse, ___E>
        for UnknownInteractionsProtocolFlexibleTwoWayErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            *out_ = ::core::mem::MaybeUninit::zeroed();

            Ok(())
        }
    }

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

                        _empty,


                } = out_;
            }

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolFlexibleTwoWayErrResponse,
        ) -> Self {
            Self {}
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl
        ::fidl_next::FromWire<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse
    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::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse
    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::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>,
        > for Box<UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<
                '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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictEventFieldsRequest {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest, ___E>
        for UnknownInteractionsProtocolStrictEventFieldsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest>
        for UnknownInteractionsProtocolStrictEventFieldsRequest
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest>
        for UnknownInteractionsProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolStrictEventUnionRequest {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for UnknownInteractionsProtocolStrictEventUnionRequest
    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::UnknownInteractionsProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolStrictEventUnionRequest<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolStrictEventUnionRequest
    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::UnknownInteractionsProtocolStrictEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolStrictEventUnionRequest::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolStrictEventUnionRequest<'de>,
        > for Box<UnknownInteractionsProtocolStrictEventUnionRequest>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolStrictEventUnionRequest<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolStrictEventTableRequest {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

    #[derive(PartialEq, Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleEventFieldsRequest {
        pub some_field: i32,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
            ___E,
        > for UnknownInteractionsProtocolFlexibleEventFieldsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            Self,
            crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::Encode<::fidl_next::WireI32, ___E>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest {
                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

                    some_field,

                } = out_;
            }

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

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(some_field.as_mut_ptr()) };

            Ok(())
        }
    }

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

            Ok(())
        }
    }

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

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest>
        for UnknownInteractionsProtocolFlexibleEventFieldsRequest
    {
        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
            crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
            Self,
        > = unsafe {
            ::fidl_next::CopyOptimization::enable_if(
                true && <i32 as ::fidl_next::FromWire<::fidl_next::WireI32>>::COPY_OPTIMIZATION
                    .is_enabled(),
            )
        };

        #[inline]
        fn from_wire(
            wire: crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWire::from_wire(wire.some_field) }
        }
    }

    impl
        ::fidl_next::FromWireRef<crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest>
        for UnknownInteractionsProtocolFlexibleEventFieldsRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::FromWireRef::from_wire_ref(&wire.some_field) }
        }
    }

    #[derive(PartialEq, Clone, Debug)]
    pub enum UnknownInteractionsProtocolFlexibleEventUnionRequest {
        SomeField(i32),

        UnknownOrdinal_(u64),
    }

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

    unsafe impl<___E>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>,
            ___E,
        > for UnknownInteractionsProtocolFlexibleEventUnionRequest
    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::UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                Self::SomeField(value) => ::fidl_next::RawWireUnion::encode_as::<
                    ___E,
                    ::fidl_next::WireI32,
                >(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::UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>,
            ___E,
        > for &'a UnknownInteractionsProtocolFlexibleEventUnionRequest
    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::UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest { raw, _phantom: _ } = out);

            match self {
                UnknownInteractionsProtocolFlexibleEventUnionRequest::SomeField(value) => {
                    ::fidl_next::RawWireUnion::encode_as::<___E, ::fidl_next::WireI32>(
                        value,
                        1,
                        encoder,
                        raw,
                        (),
                    )?
                }

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

            Ok(())
        }
    }

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

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

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

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

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

    impl<'de>
        ::fidl_next::FromWireOptionRef<
            crate::wire_optional::UnknownInteractionsProtocolFlexibleEventUnionRequest<'de>,
        > for Box<UnknownInteractionsProtocolFlexibleEventUnionRequest>
    {
        #[inline]
        fn from_wire_option_ref(
            wire: &crate::wire_optional::UnknownInteractionsProtocolFlexibleEventUnionRequest<'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(PartialEq, Clone, Debug, Default)]
    pub struct UnknownInteractionsProtocolFlexibleEventTableRequest {
        pub some_field: ::core::option::Option<i32>,
    }

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

            0
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

            let max_ord = self.__max_ordinal();

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

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

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

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

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

            Ok(())
        }
    }

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

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

            Self {
                some_field: some_field.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireI32>()
                    })
                }),
            }
        }
    }

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

pub mod wire {

    /// The wire type corresponding to [`UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            some_field
        ),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse
    {
    }

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

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

                _ => (),
            }
        }
    }

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

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

    pub mod unknown_interactions_ajar_driver_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

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

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

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

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

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

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

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

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

                        Ok(())
                    }

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

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

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

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse>(),
        1
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse
    {
    }

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

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

                _ => (),
            }
        }
    }

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

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

    pub mod unknown_interactions_ajar_driver_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_driver_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

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

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

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

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

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

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

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

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

                        Ok(())
                    }

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

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

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

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse, some_field),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {}

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

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

                _ => (),
            }
        }
    }

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

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

    pub mod unknown_interactions_ajar_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

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

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>
    {
    }

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

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

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

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

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

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

                        Ok(())
                    }

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

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

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

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayTableResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictTwoWayTableResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarProtocolStrictTwoWayErrResponse>(),
        1
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {}

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

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

                _ => (),
            }
        }
    }

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

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

    pub mod unknown_interactions_ajar_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

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

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

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

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

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

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

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

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

                        Ok(())
                    }

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

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

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

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolStrictEventFieldsRequest`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsAjarProtocolStrictEventFieldsRequest, some_field),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictEventFieldsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictEventFieldsRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictEventFieldsRequest {}

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

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

                _ => (),
            }
        }
    }

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

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

    pub mod unknown_interactions_ajar_protocol_strict_event_union_request {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_ajar_protocol_strict_event_union_request::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_protocol_strict_event_union_request::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_protocol_strict_event_union_request::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

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

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictEventUnionRequest;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>
    {
    }

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

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

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

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

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictEventTableRequest<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

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

                        Ok(())
                    }

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

    impl<'de> UnknownInteractionsAjarProtocolStrictEventTableRequest<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

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

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictEventTableRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolStrictEventTableRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolStrictEventTableRequest<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest, some_field),
        0
    );

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

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {}

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

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

                _ => (),
            }
        }
    }

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

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_ajar_protocol_flexible_event_union_request {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_ajar_protocol_flexible_event_union_request::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_ajar_protocol_flexible_event_union_request::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_ajar_protocol_flexible_event_union_request::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsAjarProtocolFlexibleEventTableRequest`].
    #[repr(C)]
    pub struct UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsAjarProtocolFlexibleEventTableRequest")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'de>
    {
        type Natural = crate::natural::UnknownInteractionsAjarProtocolFlexibleEventTableRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_closed_driver_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de>
    {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse>(
        ),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> =
            UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_closed_driver_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_closed_driver_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'static>
    {
        type Decoded<'de> =
            UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de>
    {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {}

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_closed_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsClosedProtocolStrictTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedProtocolStrictTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsClosedProtocolStrictTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsClosedProtocolStrictTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
        type Natural =
            crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_closed_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_closed_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de>
    {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictEventFieldsRequest`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsClosedProtocolStrictEventFieldsRequest, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictEventFieldsRequest;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictEventFieldsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictEventFieldsRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictEventFieldsRequest {}

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictEventUnionRequest`].
    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_closed_protocol_strict_event_union_request {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_closed_protocol_strict_event_union_request::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_closed_protocol_strict_event_union_request::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_closed_protocol_strict_event_union_request::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>
    {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictEventUnionRequest;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsClosedProtocolStrictEventTableRequest`].
    #[repr(C)]
    pub struct UnknownInteractionsClosedProtocolStrictEventTableRequest<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsClosedProtocolStrictEventTableRequest<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictEventTableRequest<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictEventTableRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictEventTableRequest<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictEventTableRequest<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictEventTableRequest<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsClosedProtocolStrictEventTableRequest")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictEventTableRequest<'de>
    {
        type Natural = crate::natural::UnknownInteractionsClosedProtocolStrictEventTableRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsClosedProtocolStrictEventTableRequest<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_driver_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsDriverProtocolStrictTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolStrictTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolStrictTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolStrictTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_driver_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_driver_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de>
    {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolFlexibleTwoWayResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolFlexibleTwoWayResponse {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolFlexibleTwoWayResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_driver_protocol_flexible_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_driver_protocol_flexible_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub fn as_ref(&self) -> crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_err_response::Ref<'_>{
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_driver_protocol_flexible_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de>
    {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'de>
    {
        type Natural =
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'_>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsProtocolStrictTwoWayFieldsResponse, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayFieldsResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_strict_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_strict_two_way_union_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_strict_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_strict_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayTableResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayTableResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolStrictTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayTableResponse<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayTableResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolStrictTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolStrictTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for UnknownInteractionsProtocolStrictTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_strict_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_strict_two_way_union_err_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_strict_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_strict_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolStrictTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolFlexibleTwoWayResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolFlexibleTwoWayResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayResponse {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for UnknownInteractionsProtocolFlexibleTwoWayResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayUnionResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_flexible_two_way_union_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_flexible_two_way_union_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_flexible_two_way_union_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_flexible_two_way_union_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayTableResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolFlexibleTwoWayTableResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayTableResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayErrResponse {
        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolFlexibleTwoWayErrResponse>(),
        1
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolFlexibleTwoWayErrResponse>(),
        1
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayErrResponse {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                        _empty,


                } = &mut *out_;
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for UnknownInteractionsProtocolFlexibleTwoWayErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                        mut _empty,


                } = slot_;
            }

            if _empty.as_bytes() != &[0u8] {
                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
            }

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayErrResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(
            UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            some_field
        ),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_flexible_two_way_union_err_response {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_flexible_two_way_union_err_response::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_flexible_two_way_union_err_response::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_flexible_two_way_union_err_response::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
    }

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'de>
    {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictEventFieldsRequest`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictEventFieldsRequest {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolStrictEventFieldsRequest>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolStrictEventFieldsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsProtocolStrictEventFieldsRequest, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictEventFieldsRequest {
        type Decoded<'de> = UnknownInteractionsProtocolStrictEventFieldsRequest;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for UnknownInteractionsProtocolStrictEventFieldsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictEventFieldsRequest {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictEventFieldsRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictEventFieldsRequest {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictEventUnionRequest`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictEventUnionRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_strict_event_union_request {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_strict_event_union_request::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_strict_event_union_request::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_strict_event_union_request::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictEventUnionRequest<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictEventUnionRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictEventUnionRequest<'static> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolStrictEventTableRequest`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolStrictEventTableRequest<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolStrictEventTableRequest<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictEventTableRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictEventTableRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictEventTableRequest<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictEventTableRequest<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictEventTableRequest<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolStrictEventTableRequest")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictEventTableRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolStrictEventTableRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictEventTableRequest<'_> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleEventFieldsRequest`].
    #[derive(Clone, Debug)]
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleEventFieldsRequest {
        pub some_field: ::fidl_next::WireI32,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<UnknownInteractionsProtocolFlexibleEventFieldsRequest>(),
        4
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<UnknownInteractionsProtocolFlexibleEventFieldsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(UnknownInteractionsProtocolFlexibleEventFieldsRequest, some_field),
        0
    );

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleEventFieldsRequest {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleEventFieldsRequest;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {

                    some_field,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(some_field);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleEventFieldsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {

                    mut some_field,

                } = slot_;
            }

            let _field = some_field.as_mut();

            ::fidl_next::Decode::decode(some_field.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleEventFieldsRequest {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleEventFieldsRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleEventFieldsRequest {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleEventUnionRequest`].
    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        fn drop(&mut self) {
            match self.raw.ordinal() {
                1 => {
                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI32>() };
                }

                _ => (),
            }
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    pub mod unknown_interactions_protocol_flexible_event_union_request {
        pub enum Ref<'de> {
            SomeField(&'de ::fidl_next::WireI32),

            UnknownOrdinal_(u64),
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        pub fn as_ref(
            &self,
        ) -> crate::wire::unknown_interactions_protocol_flexible_event_union_request::Ref<'_>
        {
            match self.raw.ordinal() {

                1 => crate::wire::unknown_interactions_protocol_flexible_event_union_request::Ref::SomeField(
                    unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI32>() }
                ),


                unknown => crate::wire::unknown_interactions_protocol_flexible_event_union_request::Ref::UnknownOrdinal_(unknown),

        }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleEventUnionRequest<'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::WireI32>().fmt(f) },
                _ => unsafe { ::core::hint::unreachable_unchecked() },
            }
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleEventUnionRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static> {}

    /// The wire type corresponding to [`UnknownInteractionsProtocolFlexibleEventTableRequest`].
    #[repr(C)]
    pub struct UnknownInteractionsProtocolFlexibleEventTableRequest<'de> {
        pub(crate) table: ::fidl_next::WireTable<'de>,
    }

    impl<'de> Drop for UnknownInteractionsProtocolFlexibleEventTableRequest<'de> {
        fn drop(&mut self) {
            let _ = self
                .table
                .get(1)
                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireI32>() });
        }
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleEventTableRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleEventTableRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { table } = out);
            ::fidl_next::WireTable::zero_padding(table);
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleEventTableRequest<'static>
    where
        ___D: ::fidl_next::Decoder + ?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::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
                match ordinal {
                    0 => unsafe { ::core::hint::unreachable_unchecked() },

                    1 => {
                        ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireI32>(
                            slot.as_mut(),
                            decoder,
                            (),
                        )?;

                        Ok(())
                    }

                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
                }
            })
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleEventTableRequest<'de> {
        pub fn some_field(&self) -> ::core::option::Option<&::fidl_next::WireI32> {
            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleEventTableRequest<'de> {
        fn fmt(
            &self,
            f: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::result::Result<(), ::core::fmt::Error> {
            f.debug_struct("UnknownInteractionsProtocolFlexibleEventTableRequest")
                .field("some_field", &self.some_field())
                .finish()
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleEventTableRequest<'de> {
        type Natural = crate::natural::UnknownInteractionsProtocolFlexibleEventTableRequest;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleEventTableRequest<'_> {}
}

pub mod wire_optional {

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static> {
        type Decoded<'de> = UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolStrictEventUnionRequest<'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::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'de> {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarProtocolStrictEventUnionRequest,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>
    {
        type Decoded<'de> = UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'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::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(
                    crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse {
                        raw: self.raw,
                        _phantom: ::core::marker::PhantomData,
                    },
                )
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> =
            UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse {
                raw: self.raw,
                _phantom: ::core::marker::PhantomData,
            })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    {
        type Decoded<'de> = UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsClosedProtocolStrictEventUnionRequest<'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::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsClosedProtocolStrictEventUnionRequest,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'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::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>
    {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayUnionResponse<'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::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'de> {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static> {}

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'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::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'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::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'de> {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'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::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'de>
    {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse,
        >;
    }

    impl ::fidl_next::Unconstrained
        for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>
    {
    }

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolStrictEventUnionRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolStrictEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolStrictEventUnionRequest<'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::UnknownInteractionsProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolStrictEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolStrictEventUnionRequest<'de> {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolStrictEventUnionRequest,
        >;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolStrictEventUnionRequest<'static> {}

    #[repr(transparent)]
    pub struct UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        pub(crate) raw: ::fidl_next::RawWireUnion,
        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
    }

    unsafe impl ::fidl_next::Wire for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static> {
        type Decoded<'de> = UnknownInteractionsProtocolFlexibleEventUnionRequest<'de>;

        #[inline]
        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
            ::fidl_next::RawWireUnion::zero_padding(raw);
        }
    }

    impl<'de> UnknownInteractionsProtocolFlexibleEventUnionRequest<'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::UnknownInteractionsProtocolFlexibleEventUnionRequest<'de>,
        > {
            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
        }

        pub fn into_option(
            self,
        ) -> ::core::option::Option<
            crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest<'de>,
        > {
            if self.is_some() {
                Some(crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest {
                    raw: self.raw,
                    _phantom: ::core::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D>
        for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder,
    {
        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::RawWireUnion::encoded_ordinal(raw.as_mut()) {
                1 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI32>(
                    raw,
                    decoder,
                    (),
                )?,

                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
            }

            Ok(())
        }
    }

    impl<'de> ::core::fmt::Debug for UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            self.as_ref().fmt(f)
        }
    }

    impl<'de> ::fidl_next::IntoNatural for UnknownInteractionsProtocolFlexibleEventUnionRequest<'de> {
        type Natural = ::core::option::Option<
            crate::natural::UnknownInteractionsProtocolFlexibleEventUnionRequest,
        >;
    }

    impl ::fidl_next::Unconstrained for UnknownInteractionsProtocolFlexibleEventUnionRequest<'static> {}
}

pub mod generic {

    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsAjarProtocolStrictEventFieldsRequest<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
            ___E,
        > for UnknownInteractionsAjarProtocolStrictEventFieldsRequest<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
            ___E,
        > for UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsClosedProtocolStrictEventFieldsRequest<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
            ___E,
        > for UnknownInteractionsClosedProtocolStrictEventFieldsRequest<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            ___E,
        > for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolStrictEventFieldsRequest<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest, ___E>
        for UnknownInteractionsProtocolStrictEventFieldsRequest<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }

    pub struct UnknownInteractionsProtocolFlexibleEventFieldsRequest<T0> {
        pub some_field: T0,
    }

    unsafe impl<___E, T0>
        ::fidl_next::Encode<
            crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
            ___E,
        > for UnknownInteractionsProtocolFlexibleEventFieldsRequest<T0>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        T0: ::fidl_next::Encode<::fidl_next::WireI32, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest {

                    some_field,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.some_field, encoder_, some_field, ())?;

            Ok(())
        }
    }
}

pub use self::natural::*;

/// The type corresponding to the UnknownInteractionsAjarDriverProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsAjarDriverProtocol;

#[cfg(feature = "driver")]
impl ::fidl_next::HasTransport for UnknownInteractionsAjarDriverProtocol {
    type Transport = ::fdf_fidl::DriverChannel;
}

pub mod unknown_interactions_ajar_driver_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsAjarDriverProtocol,
            UnknownInteractionsAjarDriverProtocolClientHandler,
            UnknownInteractionsAjarDriverProtocolServerHandler,
            unknown_interactions_ajar_driver_protocol,
        };

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 200845620698173917;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct FlexibleOneWay;

    impl ::fidl_next::Method for FlexibleOneWay {
        const ORDINAL: u64 = 3790953144423004126;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 523076268125513549;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 902155904889801604;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output =
            crate::generic::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 8952307689721713673;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 3114064683372134045;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 7057260423103547829;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 6490530264582540031;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse<
                ___R,
            >,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok

                            (crate::generic::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
                                some_field: response,
                            })
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 2319476129312263555;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 6883106306697493305;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T>
            for crate::UnknownInteractionsAjarDriverProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsAjarDriverProtocolClient<___T>;
            type Server = UnknownInteractionsAjarDriverProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsAjarDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsAjarDriverProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsAjarDriverProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    200845620698173917,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    3790953144423004126,
                    <super::FlexibleOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    523076268125513549,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    902155904889801604,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8952307689721713673,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3114064683372134045,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7057260423103547829,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6490530264582540031,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2319476129312263555,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6883106306697493305,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsAjarDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsAjarDriverProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsAjarDriverProtocolServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the UnknownInteractionsAjarDriverProtocol protocol.
///
/// See [`UnknownInteractionsAjarDriverProtocol`] for more details.
pub trait UnknownInteractionsAjarDriverProtocolClientHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___T> UnknownInteractionsAjarDriverProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for UnknownInteractionsAjarDriverProtocol
where
    ___H: UnknownInteractionsAjarDriverProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,









            <unknown_interactions_ajar_driver_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_ajar_driver_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,


{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {































            ordinal => {

                    handler.on_unknown_interaction(ordinal).await;
                    if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                        Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                    } else {
                        Ok(())
                    }

            }
        }
    }
}

/// A server handler for the UnknownInteractionsAjarDriverProtocol protocol.
///
/// See [`UnknownInteractionsAjarDriverProtocol`] for more details.
pub trait UnknownInteractionsAjarDriverProtocolServerHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_one_way(
        &mut self,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWay,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_driver_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T>
    for UnknownInteractionsAjarDriverProtocol
where
    ___H: UnknownInteractionsAjarDriverProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            200845620698173917 => {
                handler.strict_one_way().await;
                Ok(())
            }

            3790953144423004126 => {
                handler.flexible_one_way().await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            523076268125513549 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            902155904889801604 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            8952307689721713673 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            3114064683372134045 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            7057260423103547829 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            6490530264582540031 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            2319476129312263555 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            6883106306697493305 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
            }
        }
    }
}

/// The type corresponding to the UnknownInteractionsAjarProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsAjarProtocol;

#[cfg(target_os = "fuchsia")]
impl ::fidl_next::HasTransport for UnknownInteractionsAjarProtocol {
    type Transport = ::fidl_next::fuchsia::zx::Channel;
}

pub mod unknown_interactions_ajar_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsAjarProtocol, UnknownInteractionsAjarProtocolClientHandler,
            UnknownInteractionsAjarProtocolServerHandler, unknown_interactions_ajar_protocol,
        };

        pub use crate::natural::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolFlexibleEventTableRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictEventFieldsRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictEventTableRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictEventUnionRequest;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 956561744635167883;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct FlexibleOneWay;

    impl ::fidl_next::Method for FlexibleOneWay {
        const ORDINAL: u64 = 2483093178939638607;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 364341676962177080;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 1821674633227946298;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output =
            crate::generic::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 5870221221557233361;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 8038805778859962068;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 6577335136969723910;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 595881957484758745;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(
                crate::generic::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 3224530777258896533;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 3515589146717969463;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictEvent;

    impl ::fidl_next::Method for StrictEvent {
        const ORDINAL: u64 = 6927291151663612592;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = ();
    }

    pub struct StrictEventFields;

    impl ::fidl_next::Method for StrictEventFields {
        const ORDINAL: u64 = 5838220329633564521;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsAjarProtocolStrictEventFieldsRequest;
    }

    pub struct StrictEventUnion;

    impl ::fidl_next::Method for StrictEventUnion {
        const ORDINAL: u64 = 6303151946645602671;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolStrictEventUnionRequest<'static>;
    }

    pub struct StrictEventTable;

    impl ::fidl_next::Method for StrictEventTable {
        const ORDINAL: u64 = 659277224687564957;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolStrictEventTableRequest<'static>;
    }

    pub struct FlexibleEvent;

    impl ::fidl_next::Method for FlexibleEvent {
        const ORDINAL: u64 = 1281760452005010931;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = ();
    }

    pub struct FlexibleEventFields;

    impl ::fidl_next::Method for FlexibleEventFields {
        const ORDINAL: u64 = 4298964238728681570;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest;
    }

    pub struct FlexibleEventUnion;

    impl ::fidl_next::Method for FlexibleEventUnion {
        const ORDINAL: u64 = 8950943792372972717;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest<'static>;
    }

    pub struct FlexibleEventTable;

    impl ::fidl_next::Method for FlexibleEventTable {
        const ORDINAL: u64 = 705539350563403440;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsAjarProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsAjarProtocolFlexibleEventTableRequest<'static>;
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::UnknownInteractionsAjarProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsAjarProtocolClient<___T>;
            type Server = UnknownInteractionsAjarProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsAjarProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsAjarProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsAjarProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    956561744635167883,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    2483093178939638607,
                    <super::FlexibleOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    364341676962177080,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1821674633227946298,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5870221221557233361,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8038805778859962068,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6577335136969723910,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    595881957484758745,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3224530777258896533,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3515589146717969463,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsAjarProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsAjarProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsAjarProtocolServer<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_event(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    6927291151663612592,
                    <super::StrictEvent as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_event_fields(
                &self,

                some_field: impl ::fidl_next::Encode<
                    ::fidl_next::WireI32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.strict_event_fields_with(
                    crate::generic::UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
                        some_field,
                    },
                )
            }

            pub fn strict_event_fields_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventFields as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    5838220329633564521,
                    <super::StrictEventFields as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_union_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventUnion as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    6303151946645602671,
                    <super::StrictEventUnion as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_table_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventTable as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    659277224687564957,
                    <super::StrictEventTable as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    1281760452005010931,
                    <super::FlexibleEvent as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_event_fields(
                &self,

                some_field: impl ::fidl_next::Encode<
                    ::fidl_next::WireI32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.flexible_event_fields_with(
                    crate::generic::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
                        some_field,
                    },
                )
            }

            pub fn flexible_event_fields_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventFields as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    4298964238728681570,
                    <super::FlexibleEventFields as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event_union_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventUnion as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    8950943792372972717,
                    <super::FlexibleEventUnion as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event_table_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventTable as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    705539350563403440,
                    <super::FlexibleEventTable as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }
        }
    }
}

/// A client handler for the UnknownInteractionsAjarProtocol protocol.
///
/// See [`UnknownInteractionsAjarProtocol`] for more details.
pub trait UnknownInteractionsAjarProtocolClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_event(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_fields(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_union(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_table(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_fields(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_union(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_table(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___T> UnknownInteractionsAjarProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn strict_event(&mut self) {}

    async fn strict_event_fields(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventFields, ___T>,
    ) {
    }

    async fn strict_event_union(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventUnion, ___T>,
    ) {
    }

    async fn strict_event_table(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::StrictEventTable, ___T>,
    ) {
    }

    async fn flexible_event(&mut self) {}

    async fn flexible_event_fields(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventFields, ___T>,
    ) {
    }

    async fn flexible_event_union(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventUnion, ___T>,
    ) {
    }

    async fn flexible_event_table(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_ajar_protocol::FlexibleEventTable, ___T>,
    ) {
    }

    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for UnknownInteractionsAjarProtocol
where
    ___H: UnknownInteractionsAjarProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <unknown_interactions_ajar_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictEventFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictEventUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::StrictEventTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::FlexibleEventFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::FlexibleEventUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_ajar_protocol::FlexibleEventTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            6927291151663612592 => {
                handler.strict_event().await;
                Ok(())
            }

            5838220329633564521 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_fields(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 5838220329633564521,
                    error,
                }),
            },

            6303151946645602671 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_union(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 6303151946645602671,
                    error,
                }),
            },

            659277224687564957 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_table(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 659277224687564957,
                    error,
                }),
            },

            1281760452005010931 => {
                handler.flexible_event().await;
                Ok(())
            }

            4298964238728681570 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_fields(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 4298964238728681570,
                    error,
                }),
            },

            8950943792372972717 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_union(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 8950943792372972717,
                    error,
                }),
            },

            705539350563403440 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_table(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 705539350563403440,
                    error,
                }),
            },

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

/// A server handler for the UnknownInteractionsAjarProtocol protocol.
///
/// See [`UnknownInteractionsAjarProtocol`] for more details.
pub trait UnknownInteractionsAjarProtocolServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_one_way(
        &mut self,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_ajar_protocol::StrictTwoWay, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_ajar_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for UnknownInteractionsAjarProtocol
where
    ___H: UnknownInteractionsAjarProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            956561744635167883 => {
                handler.strict_one_way().await;
                Ok(())
            }

            2483093178939638607 => {
                handler.flexible_one_way().await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            364341676962177080 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            1821674633227946298 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            5870221221557233361 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            8038805778859962068 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            6577335136969723910 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            595881957484758745 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            3224530777258896533 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            3515589146717969463 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
            }
        }
    }
}

/// The type corresponding to the UnknownInteractionsClosedDriverProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsClosedDriverProtocol;

#[cfg(feature = "driver")]
impl ::fidl_next::HasTransport for UnknownInteractionsClosedDriverProtocol {
    type Transport = ::fdf_fidl::DriverChannel;
}

pub mod unknown_interactions_closed_driver_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsClosedDriverProtocol,
            UnknownInteractionsClosedDriverProtocolClientHandler,
            UnknownInteractionsClosedDriverProtocolServerHandler,
            unknown_interactions_closed_driver_protocol,
        };

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 9111839835597799810;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 2815690661228737027;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 5761316743698652038;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output =
            crate::generic::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 7235351480214368636;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 1839495150551777151;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 4350840352076287137;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 3933117456632607830;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse<
                ___R,
            >,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok

                            (crate::generic::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
                                some_field: response,
                            })
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 4598950031783776653;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse<
                'static,
            >,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 1456858375973362525;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse<
                'static,
            >,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T>
            for crate::UnknownInteractionsClosedDriverProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsClosedDriverProtocolClient<___T>;
            type Server = UnknownInteractionsClosedDriverProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsClosedDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsClosedDriverProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsClosedDriverProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    9111839835597799810,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2815690661228737027,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5761316743698652038,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7235351480214368636,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1839495150551777151,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4350840352076287137,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3933117456632607830,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4598950031783776653,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1456858375973362525,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsClosedDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsClosedDriverProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsClosedDriverProtocolServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the UnknownInteractionsClosedDriverProtocol protocol.
///
/// See [`UnknownInteractionsClosedDriverProtocol`] for more details.
pub trait UnknownInteractionsClosedDriverProtocolClientHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
}

impl<___T> UnknownInteractionsClosedDriverProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents where
    ___T: ::fidl_next::Transport
{
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for UnknownInteractionsClosedDriverProtocol
where
    ___H: UnknownInteractionsClosedDriverProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,







            <unknown_interactions_closed_driver_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_closed_driver_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,


{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {




























            ordinal => {

                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))

            }
        }
    }
}

/// A server handler for the UnknownInteractionsClosedDriverProtocol protocol.
///
/// See [`UnknownInteractionsClosedDriverProtocol`] for more details.
pub trait UnknownInteractionsClosedDriverProtocolServerHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWay,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_driver_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T>
    for UnknownInteractionsClosedDriverProtocol
where
    ___H: UnknownInteractionsClosedDriverProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            9111839835597799810 => {
                handler.strict_one_way().await;
                Ok(())
            }

            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            2815690661228737027 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            5761316743698652038 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            7235351480214368636 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            1839495150551777151 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            4350840352076287137 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            3933117456632607830 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            4598950031783776653 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            1456858375973362525 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }
}

/// The type corresponding to the UnknownInteractionsClosedProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsClosedProtocol;

#[cfg(target_os = "fuchsia")]
impl ::fidl_next::HasTransport for UnknownInteractionsClosedProtocol {
    type Transport = ::fidl_next::fuchsia::zx::Channel;
}

pub mod unknown_interactions_closed_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsClosedProtocol, UnknownInteractionsClosedProtocolClientHandler,
            UnknownInteractionsClosedProtocolServerHandler, unknown_interactions_closed_protocol,
        };

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictEventFieldsRequest;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictEventTableRequest;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictEventUnionRequest;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 401526495318825508;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 6834828562275693047;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 1379139029283639891;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output =
            crate::generic::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 7544414847426850727;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 7947328131967870853;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 5738532966428790074;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 802395819586836733;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(
                crate::generic::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 925029359463709824;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 1260407702860823440;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictEvent;

    impl ::fidl_next::Method for StrictEvent {
        const ORDINAL: u64 = 760799297757210939;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = ();
    }

    pub struct StrictEventFields;

    impl ::fidl_next::Method for StrictEventFields {
        const ORDINAL: u64 = 6736355582617074292;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsClosedProtocolStrictEventFieldsRequest;
    }

    pub struct StrictEventUnion;

    impl ::fidl_next::Method for StrictEventUnion {
        const ORDINAL: u64 = 4288682345454280036;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsClosedProtocolStrictEventUnionRequest<'static>;
    }

    pub struct StrictEventTable;

    impl ::fidl_next::Method for StrictEventTable {
        const ORDINAL: u64 = 2871682464255309246;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsClosedProtocol;

        type Request = ::fidl_next::util::Never;

        type Response =
            crate::wire::UnknownInteractionsClosedProtocolStrictEventTableRequest<'static>;
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T>
            for crate::UnknownInteractionsClosedProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsClosedProtocolClient<___T>;
            type Server = UnknownInteractionsClosedProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsClosedProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsClosedProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsClosedProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    401526495318825508,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6834828562275693047,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1379139029283639891,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7544414847426850727,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7947328131967870853,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5738532966428790074,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    802395819586836733,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    925029359463709824,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1260407702860823440,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsClosedProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsClosedProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsClosedProtocolServer<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_event(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    760799297757210939,
                    <super::StrictEvent as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_event_fields(
                &self,

                some_field: impl ::fidl_next::Encode<
                    ::fidl_next::WireI32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.strict_event_fields_with(
                    crate::generic::UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
                        some_field,
                    },
                )
            }

            pub fn strict_event_fields_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventFields as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    6736355582617074292,
                    <super::StrictEventFields as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_union_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventUnion as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    4288682345454280036,
                    <super::StrictEventUnion as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_table_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventTable as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    2871682464255309246,
                    <super::StrictEventTable as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }
        }
    }
}

/// A client handler for the UnknownInteractionsClosedProtocol protocol.
///
/// See [`UnknownInteractionsClosedProtocol`] for more details.
pub trait UnknownInteractionsClosedProtocolClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_event(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_fields(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_union(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_table(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___T> UnknownInteractionsClosedProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn strict_event(&mut self) {}

    async fn strict_event_fields(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventFields, ___T>,
    ) {
    }

    async fn strict_event_union(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventUnion, ___T>,
    ) {
    }

    async fn strict_event_table(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_closed_protocol::StrictEventTable, ___T>,
    ) {
    }
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T>
    for UnknownInteractionsClosedProtocol
where
    ___H: UnknownInteractionsClosedProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <unknown_interactions_closed_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictEventFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictEventUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_closed_protocol::StrictEventTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            760799297757210939 => {
                handler.strict_event().await;
                Ok(())
            }

            6736355582617074292 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_fields(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 6736355582617074292,
                    error,
                }),
            },

            4288682345454280036 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_union(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 4288682345454280036,
                    error,
                }),
            },

            2871682464255309246 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_table(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 2871682464255309246,
                    error,
                }),
            },

            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }
}

/// A server handler for the UnknownInteractionsClosedProtocol protocol.
///
/// See [`UnknownInteractionsClosedProtocol`] for more details.
pub trait UnknownInteractionsClosedProtocolServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_closed_protocol::StrictTwoWay, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_closed_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T>
    for UnknownInteractionsClosedProtocol
where
    ___H: UnknownInteractionsClosedProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            401526495318825508 => {
                handler.strict_one_way().await;
                Ok(())
            }

            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            6834828562275693047 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            1379139029283639891 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            7544414847426850727 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            7947328131967870853 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            5738532966428790074 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            802395819586836733 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            925029359463709824 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            1260407702860823440 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
        }
    }
}

/// The type corresponding to the UnknownInteractionsDriverProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsDriverProtocol;

#[cfg(feature = "driver")]
impl ::fidl_next::HasTransport for UnknownInteractionsDriverProtocol {
    type Transport = ::fdf_fidl::DriverChannel;
}

pub mod unknown_interactions_driver_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsDriverProtocol, UnknownInteractionsDriverProtocolClientHandler,
            UnknownInteractionsDriverProtocolServerHandler, unknown_interactions_driver_protocol,
        };

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 6982839851953080288;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct FlexibleOneWay;

    impl ::fidl_next::Method for FlexibleOneWay {
        const ORDINAL: u64 = 1083620022582160398;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 1481114722667499972;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 6841797014773573215;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output =
            crate::generic::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 1451514501977162287;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 3330693085881435529;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response =
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 8222960355260037542;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 225387363174180470;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(
                crate::generic::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 3066880266580913088;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 708169949929096689;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct FlexibleTwoWay;

    impl ::fidl_next::Method for FlexibleTwoWay {
        const ORDINAL: u64 = 2929398860738426482;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayResponse,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayFields;

    impl ::fidl_next::Method for FlexibleTwoWayFields {
        const ORDINAL: u64 = 8423663794424433896;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayFields {
        type Output = ::fidl_next::Flexible<
            crate::generic::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse<___R>,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::Flexible::Ok(
                crate::generic::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
                    some_field: response,
                },
            )
        }
    }

    pub struct FlexibleTwoWayUnion;

    impl ::fidl_next::Method for FlexibleTwoWayUnion {
        const ORDINAL: u64 = 8216450897182897849;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse<'static>,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayTable;

    impl ::fidl_next::Method for FlexibleTwoWayTable {
        const ORDINAL: u64 = 1049265954148894210;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse<'static>,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayErr;

    impl ::fidl_next::Method for FlexibleTwoWayErr {
        const ORDINAL: u64 = 5583489590753947170;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayFieldsErr;

    impl ::fidl_next::Method for FlexibleTwoWayFieldsErr {
        const ORDINAL: u64 = 6033174601748665003;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayFieldsErr {
        type Output = ::fidl_next::FlexibleResult<
            crate::generic::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(
                crate::generic::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayFieldsErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayUnionErr;

    impl ::fidl_next::Method for FlexibleTwoWayUnionErr {
        const ORDINAL: u64 = 6235121653537390575;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayUnionErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayUnionErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayTableErr;

    impl ::fidl_next::Method for FlexibleTwoWayTableErr {
        const ORDINAL: u64 = 940887795361350656;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsDriverProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayTableErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayTableErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T>
            for crate::UnknownInteractionsDriverProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsDriverProtocolClient<___T>;
            type Server = UnknownInteractionsDriverProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsDriverProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsDriverProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    6982839851953080288,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    1083620022582160398,
                    <super::FlexibleOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1481114722667499972,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6841797014773573215,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1451514501977162287,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3330693085881435529,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8222960355260037542,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    225387363174180470,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3066880266580913088,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    708169949929096689,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2929398860738426482,
                    <super::FlexibleTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8423663794424433896,
                    <super::FlexibleTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8216450897182897849,
                    <super::FlexibleTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1049265954148894210,
                    <super::FlexibleTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5583489590753947170,
                    <super::FlexibleTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6033174601748665003,
                    <super::FlexibleTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6235121653537390575,
                    <super::FlexibleTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    940887795361350656,
                    <super::FlexibleTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsDriverProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsDriverProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsDriverProtocolServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the UnknownInteractionsDriverProtocol protocol.
///
/// See [`UnknownInteractionsDriverProtocol`] for more details.
pub trait UnknownInteractionsDriverProtocolClientHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___T> UnknownInteractionsDriverProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for UnknownInteractionsDriverProtocol
where
    ___H: UnknownInteractionsDriverProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,









            <unknown_interactions_driver_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWay as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayFields as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayUnion as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayTable as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayFieldsErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayUnionErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,




            <unknown_interactions_driver_protocol::FlexibleTwoWayTableErr as ::fidl_next::Method>::Response:
                ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,


{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {























































            ordinal => {

                    handler.on_unknown_interaction(ordinal).await;
                    if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                        Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                    } else {
                        Ok(())
                    }

            }
        }
    }
}

/// A server handler for the UnknownInteractionsDriverProtocol protocol.
///
/// See [`UnknownInteractionsDriverProtocol`] for more details.
pub trait UnknownInteractionsDriverProtocolServerHandler<
    #[cfg(feature = "driver")] ___T: ::fidl_next::Transport = ::fdf_fidl::DriverChannel,
    #[cfg(not(feature = "driver"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_one_way(
        &mut self,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_driver_protocol::StrictTwoWay, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWay,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayUnion,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayTable,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_driver_protocol::FlexibleTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T>
    for UnknownInteractionsDriverProtocol
where
    ___H: UnknownInteractionsDriverProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            6982839851953080288 => {
                handler.strict_one_way().await;
                Ok(())
            }

            1083620022582160398 => {
                handler.flexible_one_way().await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            1481114722667499972 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            6841797014773573215 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            1451514501977162287 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            3330693085881435529 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            8222960355260037542 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            225387363174180470 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            3066880266580913088 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            708169949929096689 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            2929398860738426482 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way(responder).await;
                Ok(())
            }

            8423663794424433896 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_fields(responder).await;
                Ok(())
            }

            8216450897182897849 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_union(responder).await;
                Ok(())
            }

            1049265954148894210 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_table(responder).await;
                Ok(())
            }

            5583489590753947170 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_err(responder).await;
                Ok(())
            }

            6033174601748665003 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_fields_err(responder).await;
                Ok(())
            }

            6235121653537390575 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_union_err(responder).await;
                Ok(())
            }

            940887795361350656 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond(
                            ordinal,
                            flexibility,
                            ::fidl_next::Flexible::<()>::FrameworkErr(
                                ::fidl_next::FrameworkError::UnknownMethod,
                            ),
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

/// The type corresponding to the UnknownInteractionsProtocol protocol.
#[derive(PartialEq, Debug)]
pub struct UnknownInteractionsProtocol;

#[cfg(target_os = "fuchsia")]
impl ::fidl_next::HasTransport for UnknownInteractionsProtocol {
    type Transport = ::fidl_next::fuchsia::zx::Channel;
}

pub mod unknown_interactions_protocol {
    pub mod prelude {
        pub use crate::{
            UnknownInteractionsProtocol, UnknownInteractionsProtocolClientHandler,
            UnknownInteractionsProtocolServerHandler, unknown_interactions_protocol,
        };

        pub use crate::natural::UnknownInteractionsProtocolFlexibleEventFieldsRequest;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleEventTableRequest;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleEventUnionRequest;

        pub use crate::natural::UnknownInteractionsProtocolStrictEventFieldsRequest;

        pub use crate::natural::UnknownInteractionsProtocolStrictEventTableRequest;

        pub use crate::natural::UnknownInteractionsProtocolStrictEventUnionRequest;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayTableResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse;

        pub use crate::natural::UnknownInteractionsProtocolFlexibleTwoWayResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayTableErrResponse;

        pub use crate::natural::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse;
    }

    pub struct StrictOneWay;

    impl ::fidl_next::Method for StrictOneWay {
        const ORDINAL: u64 = 5652707722400962470;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct FlexibleOneWay;

    impl ::fidl_next::Method for FlexibleOneWay {
        const ORDINAL: u64 = 583422011583300678;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::util::Never;
    }

    pub struct StrictTwoWay;

    impl ::fidl_next::Method for StrictTwoWay {
        const ORDINAL: u64 = 8308184097687583042;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ();
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayFields;

    impl ::fidl_next::Method for StrictTwoWayFields {
        const ORDINAL: u64 = 3697260130745060067;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsResponse;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFields {
        type Output = crate::generic::UnknownInteractionsProtocolStrictTwoWayFieldsResponse<___R>;

        fn respond(response: ___R) -> Self::Output {
            crate::generic::UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
                some_field: response,
            }
        }
    }

    pub struct StrictTwoWayUnion;

    impl ::fidl_next::Method for StrictTwoWayUnion {
        const ORDINAL: u64 = 2455165891480464557;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayTable;

    impl ::fidl_next::Method for StrictTwoWayTable {
        const ORDINAL: u64 = 8389853739594228663;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = crate::wire::UnknownInteractionsProtocolStrictTwoWayTableResponse<'static>;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct StrictTwoWayErr;

    impl ::fidl_next::Method for StrictTwoWayErr {
        const ORDINAL: u64 = 7862264614495172967;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayFieldsErr;

    impl ::fidl_next::Method for StrictTwoWayFieldsErr {
        const ORDINAL: u64 = 2414673307948662059;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<
            crate::generic::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(
                crate::generic::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayFieldsErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayUnionErr;

    impl ::fidl_next::Method for StrictTwoWayUnionErr {
        const ORDINAL: u64 = 4988571416540160202;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayUnionErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct StrictTwoWayTableErr;

    impl ::fidl_next::Method for StrictTwoWayTableErr {
        const ORDINAL: u64 = 5487292735562672344;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::wire::UnknownInteractionsProtocolStrictTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for StrictTwoWayTableErr {
        type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct FlexibleTwoWay;

    impl ::fidl_next::Method for FlexibleTwoWay {
        const ORDINAL: u64 = 334879577560091516;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayResponse,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWay {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayFields;

    impl ::fidl_next::Method for FlexibleTwoWayFields {
        const ORDINAL: u64 = 4257018954691721778;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayFields {
        type Output = ::fidl_next::Flexible<
            crate::generic::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse<___R>,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::Flexible::Ok(
                crate::generic::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
                    some_field: response,
                },
            )
        }
    }

    pub struct FlexibleTwoWayUnion;

    impl ::fidl_next::Method for FlexibleTwoWayUnion {
        const ORDINAL: u64 = 4913460516188409782;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse<'static>,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayUnion {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayTable;

    impl ::fidl_next::Method for FlexibleTwoWayTable {
        const ORDINAL: u64 = 9171907422498283911;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexible<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayTableResponse<'static>,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayTable {
        type Output = ___R;

        fn respond(response: ___R) -> Self::Output {
            response
        }
    }

    pub struct FlexibleTwoWayErr;

    impl ::fidl_next::Method for FlexibleTwoWayErr {
        const ORDINAL: u64 = 6999736795697216519;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayFieldsErr;

    impl ::fidl_next::Method for FlexibleTwoWayFieldsErr {
        const ORDINAL: u64 = 1093132337162001157;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayFieldsErr {
        type Output = ::fidl_next::FlexibleResult<
            crate::generic::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse<___R>,
            ::fidl_next::util::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(
                crate::generic::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
                    some_field: response,
                },
            )
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayFieldsErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayUnionErr;

    impl ::fidl_next::Method for FlexibleTwoWayUnionErr {
        const ORDINAL: u64 = 2410151523245950935;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayUnionErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayUnionErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct FlexibleTwoWayTableErr;

    impl ::fidl_next::Method for FlexibleTwoWayTableErr {
        const ORDINAL: u64 = 7893309626427980786;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::wire::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse<'static>,
            ::fidl_next::WireI32,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for FlexibleTwoWayTableErr {
        type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for FlexibleTwoWayTableErr {
        type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::fidl_next::FlexibleResult::Err(response)
        }
    }

    pub struct StrictEvent;

    impl ::fidl_next::Method for StrictEvent {
        const ORDINAL: u64 = 685715276307386305;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = ();
    }

    pub struct StrictEventFields;

    impl ::fidl_next::Method for StrictEventFields {
        const ORDINAL: u64 = 8896208255987935026;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolStrictEventFieldsRequest;
    }

    pub struct StrictEventUnion;

    impl ::fidl_next::Method for StrictEventUnion {
        const ORDINAL: u64 = 3919175221694221274;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolStrictEventUnionRequest<'static>;
    }

    pub struct StrictEventTable;

    impl ::fidl_next::Method for StrictEventTable {
        const ORDINAL: u64 = 2711448698318579984;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolStrictEventTableRequest<'static>;
    }

    pub struct FlexibleEvent;

    impl ::fidl_next::Method for FlexibleEvent {
        const ORDINAL: u64 = 7042257263728687206;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = ();
    }

    pub struct FlexibleEventFields;

    impl ::fidl_next::Method for FlexibleEventFields {
        const ORDINAL: u64 = 3613822014516746241;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolFlexibleEventFieldsRequest;
    }

    pub struct FlexibleEventUnion;

    impl ::fidl_next::Method for FlexibleEventUnion {
        const ORDINAL: u64 = 2499446536152409191;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolFlexibleEventUnionRequest<'static>;
    }

    pub struct FlexibleEventTable;

    impl ::fidl_next::Method for FlexibleEventTable {
        const ORDINAL: u64 = 5724881371349617120;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::UnknownInteractionsProtocol;

        type Request = ::fidl_next::util::Never;

        type Response = crate::wire::UnknownInteractionsProtocolFlexibleEventTableRequest<'static>;
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::UnknownInteractionsProtocol
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = UnknownInteractionsProtocolClient<___T>;
            type Server = UnknownInteractionsProtocolServer<___T>;
        }

        /// The client for the `UnknownInteractionsProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsProtocolClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> UnknownInteractionsProtocolClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    5652707722400962470,
                    <super::StrictOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_one_way(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
                    583422011583300678,
                    <super::FlexibleOneWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8308184097687583042,
                    <super::StrictTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    3697260130745060067,
                    <super::StrictTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2455165891480464557,
                    <super::StrictTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    8389853739594228663,
                    <super::StrictTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7862264614495172967,
                    <super::StrictTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2414673307948662059,
                    <super::StrictTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4988571416540160202,
                    <super::StrictTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::StrictTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5487292735562672344,
                    <super::StrictTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWay, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    334879577560091516,
                    <super::FlexibleTwoWay as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_fields(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayFields, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4257018954691721778,
                    <super::FlexibleTwoWayFields as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_union(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayUnion, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4913460516188409782,
                    <super::FlexibleTwoWayUnion as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_table(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayTable, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    9171907422498283911,
                    <super::FlexibleTwoWayTable as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    6999736795697216519,
                    <super::FlexibleTwoWayErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_fields_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayFieldsErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1093132337162001157,
                    <super::FlexibleTwoWayFieldsErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_union_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayUnionErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    2410151523245950935,
                    <super::FlexibleTwoWayUnionErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_two_way_table_err(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::FlexibleTwoWayTableErr, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7893309626427980786,
                    <super::FlexibleTwoWayTableErr as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }
        }

        /// The server for the `UnknownInteractionsProtocol` protocol.
        #[repr(transparent)]
        pub struct UnknownInteractionsProtocolServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> UnknownInteractionsProtocolServer<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            pub fn strict_event(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    685715276307386305,
                    <super::StrictEvent as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn strict_event_fields(
                &self,

                some_field: impl ::fidl_next::Encode<
                    ::fidl_next::WireI32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.strict_event_fields_with(
                    crate::generic::UnknownInteractionsProtocolStrictEventFieldsRequest {
                        some_field,
                    },
                )
            }

            pub fn strict_event_fields_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventFields as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    8896208255987935026,
                    <super::StrictEventFields as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_union_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventUnion as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    3919175221694221274,
                    <super::StrictEventUnion as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn strict_event_table_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::StrictEventTable as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    2711448698318579984,
                    <super::StrictEventTable as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event(&self) -> ::fidl_next::SendFuture<'_, ___T> {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    7042257263728687206,
                    <super::FlexibleEvent as ::fidl_next::Method>::FLEXIBILITY,
                    (),
                ))
            }

            pub fn flexible_event_fields(
                &self,

                some_field: impl ::fidl_next::Encode<
                    ::fidl_next::WireI32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.flexible_event_fields_with(
                    crate::generic::UnknownInteractionsProtocolFlexibleEventFieldsRequest {
                        some_field,
                    },
                )
            }

            pub fn flexible_event_fields_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventFields as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    3613822014516746241,
                    <super::FlexibleEventFields as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event_union_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventUnion as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    2499446536152409191,
                    <super::FlexibleEventUnion as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            pub fn flexible_event_table_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <super::FlexibleEventTable as ::fidl_next::Method>::Response,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(self.server.send_event(
                    5724881371349617120,
                    <super::FlexibleEventTable as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }
        }
    }
}

/// A client handler for the UnknownInteractionsProtocol protocol.
///
/// See [`UnknownInteractionsProtocol`] for more details.
pub trait UnknownInteractionsProtocolClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_event(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_fields(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::StrictEventFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_union(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::StrictEventUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_event_table(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::StrictEventTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_fields(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_union(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_event_table(
        &mut self,

        event: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___T> UnknownInteractionsProtocolClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn strict_event(&mut self) {}

    async fn strict_event_fields(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::StrictEventFields, ___T>,
    ) {
    }

    async fn strict_event_union(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::StrictEventUnion, ___T>,
    ) {
    }

    async fn strict_event_table(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::StrictEventTable, ___T>,
    ) {
    }

    async fn flexible_event(&mut self) {}

    async fn flexible_event_fields(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventFields, ___T>,
    ) {
    }

    async fn flexible_event_union(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventUnion, ___T>,
    ) {
    }

    async fn flexible_event_table(
        &mut self,

        _: ::fidl_next::Response<unknown_interactions_protocol::FlexibleEventTable, ___T>,
    ) {
    }

    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for UnknownInteractionsProtocol
where
    ___H: UnknownInteractionsProtocolClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <unknown_interactions_protocol::StrictTwoWayFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayFieldsErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayUnionErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictTwoWayTableErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWay as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayFieldsErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayUnionErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleTwoWayTableErr as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictEventFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictEventUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::StrictEventTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleEventFields as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleEventUnion as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <unknown_interactions_protocol::FlexibleEventTable as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            685715276307386305 => {
                handler.strict_event().await;
                Ok(())
            }

            8896208255987935026 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_fields(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 8896208255987935026,
                    error,
                }),
            },

            3919175221694221274 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_union(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 3919175221694221274,
                    error,
                }),
            },

            2711448698318579984 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.strict_event_table(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 2711448698318579984,
                    error,
                }),
            },

            7042257263728687206 => {
                handler.flexible_event().await;
                Ok(())
            }

            3613822014516746241 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_fields(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 3613822014516746241,
                    error,
                }),
            },

            2499446536152409191 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_union(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 2499446536152409191,
                    error,
                }),
            },

            5724881371349617120 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.flexible_event_table(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 5724881371349617120,
                    error,
                }),
            },

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

/// A server handler for the UnknownInteractionsProtocol protocol.
///
/// See [`UnknownInteractionsProtocol`] for more details.
pub trait UnknownInteractionsProtocolServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn strict_one_way(&mut self)
    -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_one_way(
        &mut self,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::StrictTwoWay, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::StrictTwoWayFields, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::StrictTwoWayUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::StrictTwoWayTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::StrictTwoWayErr, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::StrictTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::StrictTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn strict_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::StrictTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::FlexibleTwoWay, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_fields(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::FlexibleTwoWayFields,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_union(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::FlexibleTwoWayUnion, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_table(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::FlexibleTwoWayTable, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_err(
        &mut self,

        responder: ::fidl_next::Responder<unknown_interactions_protocol::FlexibleTwoWayErr, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_fields_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::FlexibleTwoWayFieldsErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_union_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::FlexibleTwoWayUnionErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn flexible_two_way_table_err(
        &mut self,

        responder: ::fidl_next::Responder<
            unknown_interactions_protocol::FlexibleTwoWayTableErr,
            ___T,
        >,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for UnknownInteractionsProtocol
where
    ___H: UnknownInteractionsProtocolServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            5652707722400962470 => {
                handler.strict_one_way().await;
                Ok(())
            }

            583422011583300678 => {
                handler.flexible_one_way().await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        flexibility: ::fidl_next::protocol::Flexibility,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            8308184097687583042 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way(responder).await;
                Ok(())
            }

            3697260130745060067 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields(responder).await;
                Ok(())
            }

            2455165891480464557 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union(responder).await;
                Ok(())
            }

            8389853739594228663 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table(responder).await;
                Ok(())
            }

            7862264614495172967 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_err(responder).await;
                Ok(())
            }

            2414673307948662059 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_fields_err(responder).await;
                Ok(())
            }

            4988571416540160202 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_union_err(responder).await;
                Ok(())
            }

            5487292735562672344 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.strict_two_way_table_err(responder).await;
                Ok(())
            }

            334879577560091516 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way(responder).await;
                Ok(())
            }

            4257018954691721778 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_fields(responder).await;
                Ok(())
            }

            4913460516188409782 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_union(responder).await;
                Ok(())
            }

            9171907422498283911 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_table(responder).await;
                Ok(())
            }

            6999736795697216519 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_err(responder).await;
                Ok(())
            }

            1093132337162001157 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_fields_err(responder).await;
                Ok(())
            }

            2410151523245950935 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_union_err(responder).await;
                Ok(())
            }

            7893309626427980786 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.flexible_two_way_table_err(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond(
                            ordinal,
                            flexibility,
                            ::fidl_next::Flexible::<()>::FrameworkErr(
                                ::fidl_next::FrameworkError::UnknownMethod,
                            ),
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsAjarDriverProtocol`
    /// protocol.
    pub type UnknownInteractionsAjarDriverProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsAjarDriverProtocol>;

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarDriverProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsAjarDriverProtocol) -> Self {
            Self
        }
    }

    #[cfg(feature = "driver")]
    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolMarker,
        > for crate::UnknownInteractionsAjarDriverProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsAjarDriverProtocolMarker,
        ) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictEventFieldsRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn compat_from(
            value: crate::UnknownInteractionsAjarProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> for crate::UnknownInteractionsAjarProtocolStrictEventFieldsRequest {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictEventUnionRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest
    {
        fn compat_from(
            value: crate::UnknownInteractionsAjarProtocolStrictEventUnionRequest,
        ) -> Self {
            match value {
                crate::UnknownInteractionsAjarProtocolStrictEventUnionRequest::SomeField(value) => {
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value))
                }

                crate::UnknownInteractionsAjarProtocolStrictEventUnionRequest::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest,
        > for crate::UnknownInteractionsAjarProtocolStrictEventUnionRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest,
        ) -> Self {
            match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolStrictEventTableRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest
    {
        fn compat_from(
            value: crate::UnknownInteractionsAjarProtocolStrictEventTableRequest,
        ) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest,
        > for crate::UnknownInteractionsAjarProtocolStrictEventTableRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> for crate::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) -> Self {
        match value {

                crate::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> for crate::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocolFlexibleEventTableRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest {
    fn compat_from(value: crate::UnknownInteractionsAjarProtocolFlexibleEventTableRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest> for crate::UnknownInteractionsAjarProtocolFlexibleEventTableRequest {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsAjarProtocol`
    /// protocol.
    pub type UnknownInteractionsAjarProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsAjarProtocol>;

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsAjarProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsAjarProtocol) -> Self {
            Self
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolMarker,
        > for crate::UnknownInteractionsAjarProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolMarker,
        ) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl
        ::fidl_next::ClientCompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolProxy,
        > for crate::UnknownInteractionsAjarProtocol
    {
        fn client_compat_from(
            proxy: ::fidl_test_unknowninteractions::UnknownInteractionsAjarProtocolProxy,
        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::ClientDispatcher::new(client_end)
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsClosedDriverProtocol`
    /// protocol.
    pub type UnknownInteractionsClosedDriverProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsClosedDriverProtocol>;

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedDriverProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsClosedDriverProtocol) -> Self {
            Self
        }
    }

    #[cfg(feature = "driver")]
    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolMarker,
        > for crate::UnknownInteractionsClosedDriverProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsClosedDriverProtocolMarker,
        ) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictEventFieldsRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> for crate::UnknownInteractionsClosedProtocolStrictEventFieldsRequest {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictEventUnionRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictEventUnionRequest) -> Self {
        match value {

                crate::UnknownInteractionsClosedProtocolStrictEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsClosedProtocolStrictEventUnionRequest::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest> for crate::UnknownInteractionsClosedProtocolStrictEventUnionRequest {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocolStrictEventTableRequest> for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest {
    fn compat_from(value: crate::UnknownInteractionsClosedProtocolStrictEventTableRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest> for crate::UnknownInteractionsClosedProtocolStrictEventTableRequest {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsClosedProtocol`
    /// protocol.
    pub type UnknownInteractionsClosedProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsClosedProtocol>;

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsClosedProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsClosedProtocol) -> Self {
            Self
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolMarker,
        > for crate::UnknownInteractionsClosedProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolMarker,
        ) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl
        ::fidl_next::ClientCompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolProxy,
        > for crate::UnknownInteractionsClosedProtocol
    {
        fn client_compat_from(
            proxy: ::fidl_test_unknowninteractions::UnknownInteractionsClosedProtocolProxy,
        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::ClientDispatcher::new(client_end)
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse) -> Self {
        match value {

                crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse> for crate::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsDriverProtocol`
    /// protocol.
    pub type UnknownInteractionsDriverProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsDriverProtocol>;

    #[cfg(feature = "driver")]
    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsDriverProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsDriverProtocol) -> Self {
            Self
        }
    }

    #[cfg(feature = "driver")]
    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolMarker,
        > for crate::UnknownInteractionsDriverProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsDriverProtocolMarker,
        ) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn compat_from(
            value: crate::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        > for crate::UnknownInteractionsProtocolStrictTwoWayFieldsResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayUnionResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolStrictTwoWayUnionResponse) -> Self {
            match value {
                crate::UnknownInteractionsProtocolStrictTwoWayUnionResponse::SomeField(value) => {
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value))
                }

                crate::UnknownInteractionsProtocolStrictTwoWayUnionResponse::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse,
        > for crate::UnknownInteractionsProtocolStrictTwoWayUnionResponse
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse,
        ) -> Self {
            match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayTableResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolStrictTwoWayTableResponse) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse,
        > for crate::UnknownInteractionsProtocolStrictTwoWayTableResponse
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse> for crate::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse
    {
        fn compat_from(
            value: crate::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse,
        ) -> Self {
            match value {
                crate::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::SomeField(
                    value,
                ) => Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),

                crate::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse> for crate::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictTwoWayTableErrResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse
    {
        fn compat_from(
            value: crate::UnknownInteractionsProtocolStrictTwoWayTableErrResponse,
        ) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse> for crate::UnknownInteractionsProtocolStrictTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse
    {
        #[inline]
        fn compat_from(
            value: crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse> for crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse
    {
        fn compat_from(
            value: crate::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
        ) -> Self {
            match value {
                crate::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::SomeField(value) => {
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value))
                }

                crate::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
        > for crate::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
        ) -> Self {
            match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayTableResponse>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse
    {
        fn compat_from(
            value: crate::UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
        ) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
        > for crate::UnknownInteractionsProtocolFlexibleTwoWayTableResponse
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse> for crate::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse {
    #[inline]
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse {
    fn compat_from(value: crate::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse) -> Self {
        match value {

                crate::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                crate::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::UnknownOrdinal_(unknown_ordinal) =>
                    Self::__SourceBreaking { unknown_ordinal },

        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse> for crate::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse) -> Self {
        match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse> for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse {
    fn compat_from(value: crate::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

            __source_breaking: ::fidl::marker::SourceBreaking,
        }
    }
}

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse> for crate::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse {
    fn compat_from(value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse) -> Self {
        Self {

                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

        }
    }
}

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictEventFieldsRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn compat_from(value: crate::UnknownInteractionsProtocolStrictEventFieldsRequest) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest,
        > for crate::UnknownInteractionsProtocolStrictEventFieldsRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictEventUnionRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolStrictEventUnionRequest) -> Self {
            match value {
                crate::UnknownInteractionsProtocolStrictEventUnionRequest::SomeField(value) => {
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value))
                }

                crate::UnknownInteractionsProtocolStrictEventUnionRequest::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest,
        > for crate::UnknownInteractionsProtocolStrictEventUnionRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest,
        ) -> Self {
            match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolStrictEventTableRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolStrictEventTableRequest) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest,
        > for crate::UnknownInteractionsProtocolStrictEventTableRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleEventFieldsRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest
    {
        #[inline]
        fn compat_from(
            value: crate::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        > for crate::UnknownInteractionsProtocolFlexibleEventFieldsRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleEventUnionRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolFlexibleEventUnionRequest) -> Self {
            match value {
                crate::UnknownInteractionsProtocolFlexibleEventUnionRequest::SomeField(value) => {
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value))
                }

                crate::UnknownInteractionsProtocolFlexibleEventUnionRequest::UnknownOrdinal_(
                    unknown_ordinal,
                ) => Self::__SourceBreaking { unknown_ordinal },
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest,
        > for crate::UnknownInteractionsProtocolFlexibleEventUnionRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest,
        ) -> Self {
            match value {

                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::SomeField(value) =>
                    Self::SomeField(::fidl_next::CompatFrom::compat_from(value)),


                ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::__SourceBreaking { unknown_ordinal } =>
                    Self::UnknownOrdinal_(unknown_ordinal),

        }
        }
    }

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocolFlexibleEventTableRequest>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest
    {
        fn compat_from(value: crate::UnknownInteractionsProtocolFlexibleEventTableRequest) -> Self {
            Self {
                some_field: ::fidl_next::CompatFrom::compat_from(value.some_field),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest,
        > for crate::UnknownInteractionsProtocolFlexibleEventTableRequest
    {
        fn compat_from(
            value: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest,
        ) -> Self {
            Self { some_field: ::fidl_next::CompatFrom::compat_from(value.some_field) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client over `zx::Channel` for the `UnknownInteractionsProtocol`
    /// protocol.
    pub type UnknownInteractionsProtocolProxy =
        ::fidl_next::Client<crate::UnknownInteractionsProtocol>;

    impl ::fidl_next::CompatFrom<crate::UnknownInteractionsProtocol>
        for ::fidl_test_unknowninteractions::UnknownInteractionsProtocolMarker
    {
        fn compat_from(_: crate::UnknownInteractionsProtocol) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_test_unknowninteractions::UnknownInteractionsProtocolMarker>
        for crate::UnknownInteractionsProtocol
    {
        fn compat_from(
            _: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolMarker,
        ) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl
        ::fidl_next::ClientCompatFrom<
            ::fidl_test_unknowninteractions::UnknownInteractionsProtocolProxy,
        > for crate::UnknownInteractionsProtocol
    {
        fn client_compat_from(
            proxy: ::fidl_test_unknowninteractions::UnknownInteractionsProtocolProxy,
        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::ClientDispatcher::new(client_end)
        }
    }
}